add:支持基于lvgl9编译easylvgl

bsp/pc/include/luat_conf_bsp.h

@@ -187,6 +187,18 @@
 #define LV_FONT_OPPOSANS_M_16
 
 //---------------------
+
+#if defined(LUAT_USE_LVGL9)
+// LVGL 9
+#define LUAT_USE_EASYLVGL 1
+#define LUAT_USE_LVGL_SDL2 1
+#define LV_CONF_INCLUDE_SIMPLE
+
+// TP 模块与PC触摸驱动
+#define LUAT_USE_TP 1
+#define LUAT_USE_TP_PC 1
+
+#else
 // LVGL
 // 主推的UI库, 功能强大但API繁琐
 #define LUAT_USE_LVGL      1
@@ -238,6 +250,8 @@
 // #define LUAT_USE_AIRUI 1
 #endif
 
+#endif
+
 
 // 注意这里是 LUAT_USE_WINDOWS
 #ifdef _WIN32

bsp/pc/port/luat_base_mini.c

@@ -152,6 +152,9 @@ static const luaL_Reg loadedlibs[] = {
 #ifdef LUAT_USE_LVGL
   {"lvgl",   luaopen_lvgl},
 #endif
+#ifdef LUAT_USE_EASYLVGL
+  {"easylvgl", luaopen_easylvgl},
+#endif
 #ifdef LUAT_USE_LCD
   {"lcd",    luaopen_lcd},
 #endif

bsp/pc/xmake.lua

@@ -41,6 +41,10 @@ if os.getenv("LUAT_USE_GUI") == "y" then
     -- add_packages("libsdl 2.26.2")
 end
 
+if os.getenv("LUAT_USE_LVGL9") == "y" then
+    add_defines("LUAT_USE_LVGL9=1")
+end
+
 if is_host("windows") then
     add_defines("LUAT_USE_WINDOWS")
     add_defines("_CRT_SECURE_NO_WARNINGS")
@@ -308,17 +312,77 @@ target("luatos-lua")
         -- lcd
         add_includedirs(luatos.."components/lcd")
         add_files(luatos.."components/lcd/*.c")
-        -- lvgl
-        add_includedirs(luatos.."components/lvgl")
-        add_includedirs(luatos.."components/lvgl/binding")
-        add_includedirs(luatos.."components/lvgl/gen")
-        add_includedirs(luatos.."components/lvgl/src")
-        add_includedirs(luatos.."components/lvgl/font")
-        add_includedirs(luatos.."components/lvgl/src/lv_font")
-        add_includedirs(luatos.."components/lvgl/sdl2")
-        add_files(luatos.."components/lvgl/**.c")
-        -- 默认不编译lv的demos, 节省大量的编译时间
-        remove_files(luatos.."components/lvgl/lv_demos/**.c")
+        
+        -- LVGL 版本选择
+        if os.getenv("LUAT_USE_LVGL9") == "y" then
+            -- LVGL 9.4 + EasyLVGL - 最基础组件编译
+            -- LVGL 9 源码路径
+            add_includedirs(luatos.."components/easylvgl/lvgl9")
+            add_includedirs(luatos.."components/easylvgl/lvgl9/src")
+            
+            -- 先添加所有源文件
+            add_files(luatos.."components/easylvgl/lvgl9/src/**.c")
+            
+            -- 排除不需要的组件（按优先级排序）
+            -- 1. 硬件驱动（PC 模拟器不需要）
+            remove_files(luatos.."components/easylvgl/lvgl9/src/drivers/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/drivers/**/*.cpp")
+            
+            -- 2. 硬件加速绘制引擎（只保留软件渲染 SW）
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/dma2d/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/eve/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/nema_gfx/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/nxp/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/opengles/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/renesas/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/vg_lite/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/sdl/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/espressif/**/*.c")
+            remove_files(luatos.."components/easylvgl/lvgl9/src/draw/convert/**/*.c")
+            
+            -- 3. 库：排除所有，然后重新添加 bin_decoder（核心依赖）
+            -- remove_files(luatos.."components/easylvgl/lvgl9/src/libs/**/*.c")
+            -- remove_files(luatos.."components/easylvgl/lvgl9/src/libs/**/*.cpp")
+            -- add_files(luatos.."components/easylvgl/lvgl9/src/libs/bin_decoder/*.c")
+            
+            -- 4. 其他功能模块（sysmon, translation, xml 等）
+            -- remove_files(luatos.."components/easylvgl/lvgl9/src/others/**/*.c")
+            -- remove_files(luatos.."components/easylvgl/lvgl9/src/others/**/*.cpp")
+            
+            -- 5. 操作系统抽象层（如果使用 LV_OS_NONE）
+            -- remove_files(luatos.."components/easylvgl/lvgl9/src/osal/**/*.c")
+            
+            -- 6. 控件：先全部包含，确保编译通过
+            -- 所有控件都会被编译（没有被排除）
+            
+            -- 7. 保留主题编译（主题需要控件的类定义）
+            -- 主题文件会自动编译（没有被排除）
+            
+            -- EasyLVGL 核心代码
+            add_includedirs(luatos.."components/easylvgl/inc")
+            add_includedirs(luatos.."components/easylvgl/src")
+            add_files(luatos.."components/easylvgl/src/*.c")
+            
+            -- EasyLVGL Lua 绑定
+            add_includedirs(luatos.."components/easylvgl/binding")
+            add_files(luatos.."components/easylvgl/binding/*.c")
+            
+            -- EasyLVGL SDL2 驱动
+            add_includedirs(luatos.."components/easylvgl/sdl2")
+            add_files(luatos.."components/easylvgl/sdl2/*.c")
+        else
+            -- LVGL 7.13 (原有配置)
+            add_includedirs(luatos.."components/lvgl")
+            add_includedirs(luatos.."components/lvgl/binding")
+            add_includedirs(luatos.."components/lvgl/gen")
+            add_includedirs(luatos.."components/lvgl/src")
+            add_includedirs(luatos.."components/lvgl/font")
+            add_includedirs(luatos.."components/lvgl/src/lv_font")
+            add_includedirs(luatos.."components/lvgl/sdl2")
+            add_files(luatos.."components/lvgl/**.c")
+            -- 默认不编译lv的demos, 节省大量的编译时间
+            remove_files(luatos.."components/lvgl/lv_demos/**.c")
+        end
 
         -- qrcode 和 tjpgd
         add_includedirs(luatos.."components/qrcode")

components/easylvgl/binding/luat_lib_easylvgl.c

@@ -0,0 +1,197 @@
+/*
+@module  easylvgl
+@summary EasyLVGL图像库 (LVGL 9.4)
+@version 0.0.2
+@date    2024.11.07
+@tag     LUAT_USE_EASYLVGL
+@usage
+-- 初始化 EasyLVGL
+easylvgl.init(480, 320)
+
+-- 创建按钮
+local btn = easylvgl.button()
+easylvgl.button_set_callback(btn, function(obj)
+    print("Button clicked!")
+end)
+
+-- 创建标签
+local label = easylvgl.label()
+easylvgl.label_set_text(label, "Hello EasyLVGL!")
+*/
+
+#include "luat_base.h"
+#include "luat_mem.h"
+#include "luat_log.h"
+#include "rotable2.h"
+#include "../inc/easylvgl.h"
+
+#define LUAT_LOG_TAG "easylvgl"
+#include "luat_log.h"
+
+static lua_State *g_L = NULL;
+
+/**
+ * 初始化 EasyLVGL
+ * @api easylvgl.init(w, h, buff_size, buff_mode)
+ * @int 屏幕宽,可选,默认480
+ * @int 屏幕高,可选,默认320
+ * @int 缓冲区大小,可选,默认宽*10, 不含色深
+ * @int 缓冲模式,可选,默认0x06, bit0:是否使用lcdbuff bit1:buff1 bit2:buff2 bit3:是否使用lua heap
+ * @return bool 成功返回true,否则返回false
+ */
+static int l_easylvgl_init(lua_State *L) {
+    g_L = L;
+    easylvgl_set_lua_state(L);
+    
+    int w = luaL_optinteger(L, 1, 480);
+    int h = luaL_optinteger(L, 2, 320);
+    size_t buf_size = 0;
+    uint8_t buff_mode = 0x06;  // 默认双缓冲，使用 heap
+    
+    if (lua_isinteger(L, 3)) {
+        buf_size = luaL_checkinteger(L, 3);
+    }
+    
+    if (lua_isinteger(L, 4)) {
+        buff_mode = luaL_checkinteger(L, 4);
+    }
+    
+    int ret = easylvgl_init_internal(w, h, buf_size, buff_mode);
+    lua_pushboolean(L, ret == 0);
+    return 1;
+}
+
+/**
+ * 创建按钮对象
+ * @api easylvgl.button(parent)
+ * @userdata 父对象,可选,默认使用屏幕
+ * @return userdata 按钮对象指针
+ */
+static int l_easylvgl_button(lua_State *L) {
+    lv_obj_t *parent = NULL;
+    
+    if (lua_isuserdata(L, 1)) {
+        parent = (lv_obj_t *)lua_touserdata(L, 1);
+    }
+    
+    lv_obj_t *btn = easylvgl_button_create(parent);
+    if (btn == NULL) {
+        lua_pushnil(L);
+        return 1;
+    }
+    
+    lua_pushlightuserdata(L, btn);
+    return 1;
+}
+
+/**
+ * 设置按钮点击回调
+ * @api easylvgl.button_set_callback(btn, callback)
+ * @userdata 按钮对象
+ * @function 回调函数,接收按钮对象作为参数
+ * @return nil
+ */
+static int l_easylvgl_button_set_callback(lua_State *L) {
+    if (!lua_isuserdata(L, 1)) {
+        luaL_error(L, "expect userdata for button");
+        return 0;
+    }
+    
+    if (!lua_isfunction(L, 2)) {
+        luaL_error(L, "expect function for callback");
+        return 0;
+    }
+    
+    lv_obj_t *btn = (lv_obj_t *)lua_touserdata(L, 1);
+    
+    // 将回调函数保存到注册表
+    int callback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+    
+    easylvgl_button_set_callback(btn, callback_ref);
+    
+    return 0;
+}
+
+/**
+ * 创建标签对象
+ * @api easylvgl.label(parent)
+ * @userdata 父对象,可选,默认使用屏幕
+ * @return userdata 标签对象指针
+ */
+static int l_easylvgl_label(lua_State *L) {
+    lv_obj_t *parent = NULL;
+    
+    if (lua_isuserdata(L, 1)) {
+        parent = (lv_obj_t *)lua_touserdata(L, 1);
+    }
+    
+    lv_obj_t *label = easylvgl_label_create(parent);
+    if (label == NULL) {
+        lua_pushnil(L);
+        return 1;
+    }
+    
+    lua_pushlightuserdata(L, label);
+    return 1;
+}
+
+/**
+ * 设置标签文本
+ * @api easylvgl.label_set_text(label, text)
+ * @userdata 标签对象
+ * @string 文本内容
+ * @return nil
+ */
+static int l_easylvgl_label_set_text(lua_State *L) {
+    if (!lua_isuserdata(L, 1)) {
+        luaL_error(L, "expect userdata for label");
+        return 0;
+    }
+    
+    const char *text = luaL_checkstring(L, 2);
+    lv_obj_t *label = (lv_obj_t *)lua_touserdata(L, 1);
+    
+    easylvgl_label_set_text(label, text);
+    
+    return 0;
+}
+
+/**
+ * 获取标签文本
+ * @api easylvgl.label_get_text(label)
+ * @userdata 标签对象
+ * @return string 文本内容
+ */
+static int l_easylvgl_label_get_text(lua_State *L) {
+    if (!lua_isuserdata(L, 1)) {
+        luaL_error(L, "expect userdata for label");
+        return 0;
+    }
+    
+    lv_obj_t *label = (lv_obj_t *)lua_touserdata(L, 1);
+    const char *text = easylvgl_label_get_text(label);
+    
+    if (text == NULL) {
+        lua_pushnil(L);
+    } else {
+        lua_pushstring(L, text);
+    }
+    
+    return 1;
+}
+
+static const rotable_Reg_t reg_easylvgl[] = {
+    {"init", ROREG_FUNC(l_easylvgl_init)},
+    {"button", ROREG_FUNC(l_easylvgl_button)},
+    {"button_set_callback", ROREG_FUNC(l_easylvgl_button_set_callback)},
+    {"label", ROREG_FUNC(l_easylvgl_label)},
+    {"label_set_text", ROREG_FUNC(l_easylvgl_label_set_text)},
+    {"label_get_text", ROREG_FUNC(l_easylvgl_label_get_text)},
+    {NULL, ROREG_INT(0)}
+};
+
+LUAMOD_API int luaopen_easylvgl(lua_State *L) {
+    luat_newlib2(L, reg_easylvgl);
+    return 1;
+}
+

components/easylvgl/inc/easylvgl.h

@@ -0,0 +1,105 @@
+/**
+ * @file easylvgl.h
+ * @summary EasyLVGL 核心接口头文件 (LVGL 9.4)
+ * @version 0.0.2
+ */
+
+#ifndef EASYLVGL_H
+#define EASYLVGL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "luat_base.h"
+#include "../lvgl9/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * EasyLVGL 显示驱动结构
+ */
+typedef struct {
+    lv_display_t *display;      /**< LVGL 9 显示对象 */
+    void *buf1;                 /**< 缓冲区1 */
+    void *buf2;                 /**< 缓冲区2 */
+    uint32_t buf_size;          /**< 缓冲区大小（字节） */
+    int buf1_ref;               /**< Lua 引用（如果使用 Lua heap） */
+    int buf2_ref;               /**< Lua 引用（如果使用 Lua heap） */
+} easylvgl_display_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * 初始化 EasyLVGL
+ * @param w 屏幕宽度
+ * @param h 屏幕高度
+ * @param buf_size 缓冲区大小（像素数，不含色深）
+ * @param buff_mode 缓冲模式 bit0:是否使用lcdbuff bit1:buff1 bit2:buff2 bit3:是否使用lua heap
+ * @return 成功返回0，失败返回-1
+ */
+int easylvgl_init_internal(int w, int h, size_t buf_size, uint8_t buff_mode);
+
+/**
+ * 显示刷新回调（LVGL 9 格式）
+ * @param disp 显示对象
+ * @param area 刷新区域
+ * @param px_map 像素数据（uint8_t* 格式）
+ */
+void easylvgl_disp_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *px_map);
+
+/**
+ * 创建按钮对象
+ * @param parent 父对象
+ * @return 按钮对象指针
+ */
+lv_obj_t *easylvgl_button_create(lv_obj_t *parent);
+
+/**
+ * 设置按钮点击回调
+ * @param btn 按钮对象
+ * @param callback Lua 回调函数引用
+ */
+void easylvgl_button_set_callback(lv_obj_t *btn, int callback_ref);
+
+/**
+ * 设置全局 Lua 状态（用于回调）
+ * @param L Lua 状态指针
+ */
+void easylvgl_set_lua_state(lua_State *L);
+
+/**
+ * 创建标签对象
+ * @param parent 父对象
+ * @return 标签对象指针
+ */
+lv_obj_t *easylvgl_label_create(lv_obj_t *parent);
+
+/**
+ * 设置标签文本
+ * @param label 标签对象
+ * @param text 文本内容
+ */
+void easylvgl_label_set_text(lv_obj_t *label, const char *text);
+
+/**
+ * 获取标签文本
+ * @param label 标签对象
+ * @return 文本内容指针
+ */
+const char *easylvgl_label_get_text(lv_obj_t *label);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*EASYLVGL_H*/
+

components/easylvgl/lvgl9/lv_conf.h

@@ -0,0 +1,1475 @@
+/**
+ * @file lv_conf.h
+ * Configuration file for v9.4.0
+ */
+
+/*
+ * Copy this file as `lv_conf.h`
+ * 1. simply next to `lvgl` folder
+ * 2. or to any other place and
+ *    - define `LV_CONF_INCLUDE_SIMPLE`;
+ *    - add the path as an include path.
+ */
+
+/* clang-format off */
+#if 1 /* Set this to "1" to enable content */
+
+#ifndef LV_CONF_H
+#define LV_CONF_H
+
+/* If you need to include anything here, do it inside the `__ASSEMBLY__` guard */
+#if  0 && defined(__ASSEMBLY__)
+#include "my_include.h"
+#endif
+
+/*====================
+   COLOR SETTINGS
+ *====================*/
+
+/** Color depth: 1 (I1), 8 (L8), 16 (RGB565), 24 (RGB888), 32 (XRGB8888) */
+#define LV_COLOR_DEPTH 16
+
+/*=========================
+   STDLIB WRAPPER SETTINGS
+ *=========================*/
+
+/** Possible values
+ * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
+ * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
+ * - LV_STDLIB_MICROPYTHON: MicroPython implementation
+ * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
+ * - LV_STDLIB_CUSTOM:      Implement the functions externally
+ */
+#define LV_USE_STDLIB_MALLOC    LV_STDLIB_BUILTIN
+
+/** Possible values
+ * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
+ * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
+ * - LV_STDLIB_MICROPYTHON: MicroPython implementation
+ * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
+ * - LV_STDLIB_CUSTOM:      Implement the functions externally
+ */
+#define LV_USE_STDLIB_STRING    LV_STDLIB_BUILTIN
+
+/** Possible values
+ * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
+ * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
+ * - LV_STDLIB_MICROPYTHON: MicroPython implementation
+ * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
+ * - LV_STDLIB_CUSTOM:      Implement the functions externally
+ */
+#define LV_USE_STDLIB_SPRINTF   LV_STDLIB_BUILTIN
+
+#define LV_STDINT_INCLUDE       <stdint.h>
+#define LV_STDDEF_INCLUDE       <stddef.h>
+#define LV_STDBOOL_INCLUDE      <stdbool.h>
+#define LV_INTTYPES_INCLUDE     <inttypes.h>
+#define LV_LIMITS_INCLUDE       <limits.h>
+#define LV_STDARG_INCLUDE       <stdarg.h>
+
+#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
+    /** Size of memory available for `lv_malloc()` in bytes (>= 2kB) */
+    #define LV_MEM_SIZE (64 * 1024U)          /**< [bytes] */
+
+    /** Size of the memory expand for `lv_malloc()` in bytes */
+    #define LV_MEM_POOL_EXPAND_SIZE 0
+
+    /** Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too. */
+    #define LV_MEM_ADR 0     /**< 0: unused*/
+    /* Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc */
+    #if LV_MEM_ADR == 0
+        #undef LV_MEM_POOL_INCLUDE
+        #undef LV_MEM_POOL_ALLOC
+    #endif
+#endif  /*LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN*/
+
+/*====================
+   HAL SETTINGS
+ *====================*/
+
+/** Default display refresh, input device read and animation step period. */
+#define LV_DEF_REFR_PERIOD  33      /**< [ms] */
+
+/** Default Dots Per Inch. Used to initialize default sizes such as widgets sized, style paddings.
+ * (Not so important, you can adjust it to modify default sizes and spaces.) */
+#define LV_DPI_DEF 130              /**< [px/inch] */
+
+/*=================
+ * OPERATING SYSTEM
+ *=================*/
+/** Select operating system to use. Possible options:
+ * - LV_OS_NONE
+ * - LV_OS_PTHREAD
+ * - LV_OS_FREERTOS
+ * - LV_OS_CMSIS_RTOS2
+ * - LV_OS_RTTHREAD
+ * - LV_OS_WINDOWS
+ * - LV_OS_MQX
+ * - LV_OS_SDL2
+ * - LV_OS_CUSTOM */
+#define LV_USE_OS   LV_OS_NONE
+
+#if LV_USE_OS == LV_OS_CUSTOM
+    #define LV_OS_CUSTOM_INCLUDE <stdint.h>
+#endif
+#if LV_USE_OS == LV_OS_FREERTOS
+    /*
+     * Unblocking an RTOS task with a direct notification is 45% faster and uses less RAM
+     * than unblocking a task using an intermediary object such as a binary semaphore.
+     * RTOS task notifications can only be used when there is only one task that can be the recipient of the event.
+     */
+    #define LV_USE_FREERTOS_TASK_NOTIFY 1
+#endif
+
+/*========================
+ * RENDERING CONFIGURATION
+ *========================*/
+
+/** Align stride of all layers and images to this bytes */
+#define LV_DRAW_BUF_STRIDE_ALIGN                1
+
+/** Align start address of draw_buf addresses to this bytes*/
+#define LV_DRAW_BUF_ALIGN                       4
+
+/** Using matrix for transformations.
+ * Requirements:
+ * - `LV_USE_MATRIX = 1`.
+ * - Rendering engine needs to support 3x3 matrix transformations. */
+#define LV_DRAW_TRANSFORM_USE_MATRIX            0
+
+/* If a widget has `style_opa < 255` (not `bg_opa`, `text_opa` etc) or not NORMAL blend mode
+ * it is buffered into a "simple" layer before rendering. The widget can be buffered in smaller chunks.
+ * "Transformed layers" (if `transform_angle/zoom` are set) use larger buffers
+ * and can't be drawn in chunks. */
+
+/** The target buffer size for simple layer chunks. */
+#define LV_DRAW_LAYER_SIMPLE_BUF_SIZE    (24 * 1024)    /**< [bytes]*/
+
+/* Limit the max allocated memory for simple and transformed layers.
+ * It should be at least `LV_DRAW_LAYER_SIMPLE_BUF_SIZE` sized but if transformed layers are also used
+ * it should be enough to store the largest widget too (width x height x 4 area).
+ * Set it to 0 to have no limit. */
+#define LV_DRAW_LAYER_MAX_MEMORY 0  /**< No limit by default [bytes]*/
+
+/** Stack size of drawing thread.
+ * NOTE: If FreeType or ThorVG is enabled, it is recommended to set it to 32KB or more.
+ */
+#define LV_DRAW_THREAD_STACK_SIZE    (8 * 1024)         /**< [bytes]*/
+
+/** Thread priority of the drawing task.
+ *  Higher values mean higher priority.
+ *  Can use values from lv_thread_prio_t enum in lv_os.h: LV_THREAD_PRIO_LOWEST,
+ *  LV_THREAD_PRIO_LOW, LV_THREAD_PRIO_MID, LV_THREAD_PRIO_HIGH, LV_THREAD_PRIO_HIGHEST
+ *  Make sure the priority value aligns with the OS-specific priority levels.
+ *  On systems with limited priority levels (e.g., FreeRTOS), a higher value can improve
+ *  rendering performance but might cause other tasks to starve. */
+#define LV_DRAW_THREAD_PRIO LV_THREAD_PRIO_HIGH
+
+#define LV_USE_DRAW_SW 1
+#if LV_USE_DRAW_SW == 1
+    /*
+     * Selectively disable color format support in order to reduce code size.
+     * NOTE: some features use certain color formats internally, e.g.
+     * - gradients use RGB888
+     * - bitmaps with transparency may use ARGB8888
+     */
+    #define LV_DRAW_SW_SUPPORT_RGB565       1
+    #define LV_DRAW_SW_SUPPORT_RGB565_SWAPPED       1
+    #define LV_DRAW_SW_SUPPORT_RGB565A8     1
+    #define LV_DRAW_SW_SUPPORT_RGB888       1
+    #define LV_DRAW_SW_SUPPORT_XRGB8888     1
+    #define LV_DRAW_SW_SUPPORT_ARGB8888     1
+    #define LV_DRAW_SW_SUPPORT_ARGB8888_PREMULTIPLIED 1
+    #define LV_DRAW_SW_SUPPORT_L8           1
+    #define LV_DRAW_SW_SUPPORT_AL88         1
+    #define LV_DRAW_SW_SUPPORT_A8           1
+    #define LV_DRAW_SW_SUPPORT_I1           1
+
+    /* The threshold of the luminance to consider a pixel as
+     * active in indexed color format */
+    #define LV_DRAW_SW_I1_LUM_THRESHOLD 127
+
+    /** Set number of draw units.
+     *  - > 1 requires operating system to be enabled in `LV_USE_OS`.
+     *  - > 1 means multiple threads will render the screen in parallel. */
+    #define LV_DRAW_SW_DRAW_UNIT_CNT    1
+
+    /** Use Arm-2D to accelerate software (sw) rendering. */
+    #define LV_USE_DRAW_ARM2D_SYNC      0
+
+    /** Enable native helium assembly to be compiled. */
+    #define LV_USE_NATIVE_HELIUM_ASM    0
+
+    /**
+     * - 0: Use a simple renderer capable of drawing only simple rectangles with gradient, images, text, and straight lines only.
+     * - 1: Use a complex renderer capable of drawing rounded corners, shadow, skew lines, and arcs too. */
+    #define LV_DRAW_SW_COMPLEX          1
+
+    #if LV_DRAW_SW_COMPLEX == 1
+        /** Allow buffering some shadow calculation.
+         *  LV_DRAW_SW_SHADOW_CACHE_SIZE is the maximum shadow size to buffer, where shadow size is
+         *  `shadow_width + radius`.  Caching has LV_DRAW_SW_SHADOW_CACHE_SIZE^2 RAM cost. */
+        #define LV_DRAW_SW_SHADOW_CACHE_SIZE 0
+
+        /** Set number of maximally-cached circle data.
+         *  The circumference of 1/4 circle are saved for anti-aliasing.
+         *  `radius * 4` bytes are used per circle (the most often used radiuses are saved).
+         *  - 0: disables caching */
+        #define LV_DRAW_SW_CIRCLE_CACHE_SIZE 4
+    #endif
+
+    #define  LV_USE_DRAW_SW_ASM     LV_DRAW_SW_ASM_NONE
+
+    #if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_CUSTOM
+        #define  LV_DRAW_SW_ASM_CUSTOM_INCLUDE ""
+    #endif
+
+    /** Enable drawing complex gradients in software: linear at an angle, radial or conical */
+    #define LV_USE_DRAW_SW_COMPLEX_GRADIENTS    0
+
+#endif
+
+/*Use TSi's aka (Think Silicon) NemaGFX */
+#define LV_USE_NEMA_GFX 0
+
+#if LV_USE_NEMA_GFX
+    /** Select which NemaGFX HAL to use. Possible options:
+     * - LV_NEMA_HAL_CUSTOM
+     * - LV_NEMA_HAL_STM32 */
+    #define LV_USE_NEMA_HAL LV_NEMA_HAL_CUSTOM
+    #if LV_USE_NEMA_HAL == LV_NEMA_HAL_STM32
+        #define LV_NEMA_STM32_HAL_INCLUDE <stm32u5xx_hal.h>
+    #endif
+
+    /*Enable Vector Graphics Operations. Available only if NemaVG library is present*/
+    #define LV_USE_NEMA_VG 0
+    #if LV_USE_NEMA_VG
+        /*Define application's resolution used for VG related buffer allocation */
+        #define LV_NEMA_GFX_MAX_RESX 800
+        #define LV_NEMA_GFX_MAX_RESY 600
+    #endif
+#endif
+
+/** Use NXP's PXP on iMX RTxxx platforms. */
+#define LV_USE_PXP 0
+
+#if LV_USE_PXP
+    /** Use PXP for drawing.*/
+    #define LV_USE_DRAW_PXP 1
+
+    /** Use PXP to rotate display.*/
+    #define LV_USE_ROTATE_PXP 0
+
+    #if LV_USE_DRAW_PXP && LV_USE_OS
+        /** Use additional draw thread for PXP processing.*/
+        #define LV_USE_PXP_DRAW_THREAD 1
+    #endif
+
+    /** Enable PXP asserts. */
+    #define LV_USE_PXP_ASSERT 0
+#endif
+
+/** Use NXP's G2D on MPU platforms. */
+#define LV_USE_G2D 0
+
+#if LV_USE_G2D
+    /** Use G2D for drawing. **/
+    #define LV_USE_DRAW_G2D 1
+
+    /** Use G2D to rotate display. **/
+    #define LV_USE_ROTATE_G2D 0
+
+    /** Maximum number of buffers that can be stored for G2D draw unit.
+     *  Includes the frame buffers and assets. */
+    #define LV_G2D_HASH_TABLE_SIZE 50
+
+    #if LV_USE_DRAW_G2D && LV_USE_OS
+        /** Use additional draw thread for G2D processing.*/
+        #define LV_USE_G2D_DRAW_THREAD 1
+    #endif
+
+    /** Enable G2D asserts. */
+    #define LV_USE_G2D_ASSERT 0
+#endif
+
+/** Use Renesas Dave2D on RA  platforms. */
+#define LV_USE_DRAW_DAVE2D 0
+
+/** Draw using cached SDL textures*/
+#define LV_USE_DRAW_SDL 0
+
+/** Use VG-Lite GPU. */
+#define LV_USE_DRAW_VG_LITE 0
+#if LV_USE_DRAW_VG_LITE
+    /** Enable VG-Lite custom external 'gpu_init()' function */
+    #define LV_VG_LITE_USE_GPU_INIT 0
+
+    /** Enable VG-Lite assert. */
+    #define LV_VG_LITE_USE_ASSERT 0
+
+    /** VG-Lite flush commit trigger threshold. GPU will try to batch these many draw tasks. */
+    #define LV_VG_LITE_FLUSH_MAX_COUNT 8
+
+    /** Enable border to simulate shadow.
+     *  NOTE: which usually improves performance,
+     *  but does not guarantee the same rendering quality as the software. */
+    #define LV_VG_LITE_USE_BOX_SHADOW 1
+
+    /** VG-Lite gradient maximum cache number.
+     *  @note  The memory usage of a single gradient image is 4K bytes. */
+    #define LV_VG_LITE_GRAD_CACHE_CNT 32
+
+    /** VG-Lite stroke maximum cache number. */
+    #define LV_VG_LITE_STROKE_CACHE_CNT 32
+
+    /** Remove VLC_OP_CLOSE path instruction (Workaround for NXP) **/
+    #define LV_VG_LITE_DISABLE_VLC_OP_CLOSE 0
+
+    /** Disable linear gradient extension for some older versions of drivers. */
+    #define LV_VG_LITE_DISABLE_LINEAR_GRADIENT_EXT 0
+
+    /** Enable usage of the LVGL's built-in vg_lite driver */
+    #define LV_USE_VG_LITE_DRIVER  0
+    #if LV_USE_VG_LITE_DRIVER
+        /** Used to pick the correct GPU series folder valid options are gc255, gc355 and gc555*/
+        #define LV_VG_LITE_HAL_GPU_SERIES gc255
+
+        /** Used to pick the correct GPU revision header it depends on the vendor */
+        #define LV_VG_LITE_HAL_GPU_REVISION 0x40
+
+        /** Base memory address of the GPU IP it depends on SoC,
+         *  default value is for NXP based devices */
+        #define LV_VG_LITE_HAL_GPU_BASE_ADDRESS 0x40240000
+    #endif /*LV_USE_VG_LITE_DRIVER*/
+
+    /** Use ThorVG (a software vector library) as VG-Lite driver to allow testing VGLite on PC
+     *  Requires: LV_USE_THORVG_INTERNAL or LV_USE_THORVG_EXTERNAL */
+    #define LV_USE_VG_LITE_THORVG   0
+    #if LV_USE_VG_LITE_THORVG
+        /** Enable LVGL's blend mode support */
+        #define LV_VG_LITE_THORVG_LVGL_BLEND_SUPPORT 0
+
+        /** Enable YUV color format support */
+        #define LV_VG_LITE_THORVG_YUV_SUPPORT 0
+
+        /** Enable Linear gradient extension support */
+        #define LV_VG_LITE_THORVG_LINEAR_GRADIENT_EXT_SUPPORT 0
+
+        /** Enable alignment on 16 pixels */
+        #define LV_VG_LITE_THORVG_16PIXELS_ALIGN 1
+
+        /** Buffer address alignment */
+        #define LV_VG_LITE_THORVG_BUF_ADDR_ALIGN 64
+
+        /** Enable multi-thread render */
+        #define LV_VG_LITE_THORVG_THREAD_RENDER 0
+    #endif /*LV_USE_VG_LITE_THORVG*/
+#endif
+
+/** Accelerate blends, fills, etc. with STM32 DMA2D */
+#define LV_USE_DRAW_DMA2D 0
+#if LV_USE_DRAW_DMA2D
+    #define LV_DRAW_DMA2D_HAL_INCLUDE "stm32h7xx_hal.h"
+
+    /* if enabled, the user is required to call `lv_draw_dma2d_transfer_complete_interrupt_handler`
+     * upon receiving the DMA2D global interrupt
+     */
+    #define LV_USE_DRAW_DMA2D_INTERRUPT 0
+#endif
+
+/** Draw using cached OpenGLES textures. Requires LV_USE_OPENGLES */
+#define LV_USE_DRAW_OPENGLES 0
+#if LV_USE_DRAW_OPENGLES
+    #define LV_DRAW_OPENGLES_TEXTURE_CACHE_COUNT 64
+#endif
+
+/** Draw using espressif PPA accelerator */
+#define LV_USE_PPA  0
+#if LV_USE_PPA
+    #define LV_USE_PPA_IMG 0
+#endif
+
+/* Use EVE FT81X GPU. */
+#define LV_USE_DRAW_EVE 0
+#if LV_USE_DRAW_EVE
+    /* EVE_GEN value: 2, 3, or 4 */
+    #define LV_DRAW_EVE_EVE_GENERATION 4
+
+    /* The maximum number of bytes to buffer before a single SPI transmission.
+     * Set it to 0 to disable write buffering.
+     */
+    #define LV_DRAW_EVE_WRITE_BUFFER_SIZE 2048
+#endif
+
+/*=======================
+ * FEATURE CONFIGURATION
+ *=======================*/
+
+/*-------------
+ * Logging
+ *-----------*/
+
+/** Enable log module */
+#define LV_USE_LOG 0
+#if LV_USE_LOG
+    /** Set value to one of the following levels of logging detail:
+     *  - LV_LOG_LEVEL_TRACE    Log detailed information.
+     *  - LV_LOG_LEVEL_INFO     Log important events.
+     *  - LV_LOG_LEVEL_WARN     Log if something unwanted happened but didn't cause a problem.
+     *  - LV_LOG_LEVEL_ERROR    Log only critical issues, when system may fail.
+     *  - LV_LOG_LEVEL_USER     Log only custom log messages added by the user.
+     *  - LV_LOG_LEVEL_NONE     Do not log anything. */
+    #define LV_LOG_LEVEL LV_LOG_LEVEL_WARN
+
+    /** - 1: Print log with 'printf';
+     *  - 0: User needs to register a callback with `lv_log_register_print_cb()`. */
+    #define LV_LOG_PRINTF 0
+
+    /** Set callback to print logs.
+     *  E.g `my_print`. The prototype should be `void my_print(lv_log_level_t level, const char * buf)`.
+     *  Can be overwritten by `lv_log_register_print_cb`. */
+    //#define LV_LOG_PRINT_CB
+
+    /** - 1: Enable printing timestamp;
+     *  - 0: Disable printing timestamp. */
+    #define LV_LOG_USE_TIMESTAMP 1
+
+    /** - 1: Print file and line number of the log;
+     *  - 0: Do not print file and line number of the log. */
+    #define LV_LOG_USE_FILE_LINE 1
+
+    /* Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs. */
+    #define LV_LOG_TRACE_MEM        1   /**< Enable/disable trace logs in memory operations. */
+    #define LV_LOG_TRACE_TIMER      1   /**< Enable/disable trace logs in timer operations. */
+    #define LV_LOG_TRACE_INDEV      1   /**< Enable/disable trace logs in input device operations. */
+    #define LV_LOG_TRACE_DISP_REFR  1   /**< Enable/disable trace logs in display re-draw operations. */
+    #define LV_LOG_TRACE_EVENT      1   /**< Enable/disable trace logs in event dispatch logic. */
+    #define LV_LOG_TRACE_OBJ_CREATE 1   /**< Enable/disable trace logs in object creation (core `obj` creation plus every widget). */
+    #define LV_LOG_TRACE_LAYOUT     1   /**< Enable/disable trace logs in flex- and grid-layout operations. */
+    #define LV_LOG_TRACE_ANIM       1   /**< Enable/disable trace logs in animation logic. */
+    #define LV_LOG_TRACE_CACHE      1   /**< Enable/disable trace logs in cache operations. */
+#endif  /*LV_USE_LOG*/
+
+/*-------------
+ * Asserts
+ *-----------*/
+
+/* Enable assertion failures if an operation fails or invalid data is found.
+ * If LV_USE_LOG is enabled, an error message will be printed on failure. */
+#define LV_USE_ASSERT_NULL          1   /**< Check if the parameter is NULL. (Very fast, recommended) */
+#define LV_USE_ASSERT_MALLOC        1   /**< Checks is the memory is successfully allocated or no. (Very fast, recommended) */
+#define LV_USE_ASSERT_STYLE         0   /**< Check if the styles are properly initialized. (Very fast, recommended) */
+#define LV_USE_ASSERT_MEM_INTEGRITY 0   /**< Check the integrity of `lv_mem` after critical operations. (Slow) */
+#define LV_USE_ASSERT_OBJ           0   /**< Check the object's type and existence (e.g. not deleted). (Slow) */
+
+/** Add a custom handler when assert happens e.g. to restart MCU. */
+#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
+#define LV_ASSERT_HANDLER while(1);     /**< Halt by default */
+
+/*-------------
+ * Debug
+ *-----------*/
+
+/** 1: Draw random colored rectangles over the redrawn areas. */
+#define LV_USE_REFR_DEBUG 0
+
+/** 1: Draw a red overlay for ARGB layers and a green overlay for RGB layers*/
+#define LV_USE_LAYER_DEBUG 0
+
+/** 1: Adds the following behaviors for debugging:
+ *  - Draw overlays with different colors for each draw_unit's tasks.
+ *  - Draw index number of draw unit on white background.
+ *  - For layers, draws index number of draw unit on black background. */
+#define LV_USE_PARALLEL_DRAW_DEBUG 0
+
+/*-------------
+ * Others
+ *-----------*/
+
+#define LV_ENABLE_GLOBAL_CUSTOM 0
+#if LV_ENABLE_GLOBAL_CUSTOM
+    /** Header to include for custom 'lv_global' function" */
+    #define LV_GLOBAL_CUSTOM_INCLUDE <stdint.h>
+#endif
+
+/** Default cache size in bytes.
+ *  Used by image decoders such as `lv_lodepng` to keep the decoded image in memory.
+ *  If size is not set to 0, the decoder will fail to decode when the cache is full.
+ *  If size is 0, the cache function is not enabled and the decoded memory will be
+ *  released immediately after use. */
+#define LV_CACHE_DEF_SIZE       0
+
+/** Default number of image header cache entries. The cache is used to store the headers of images
+ *  The main logic is like `LV_CACHE_DEF_SIZE` but for image headers. */
+#define LV_IMAGE_HEADER_CACHE_DEF_CNT 0
+
+/** Number of stops allowed per gradient. Increase this to allow more stops.
+ *  This adds (sizeof(lv_color_t) + 1) bytes per additional stop. */
+#define LV_GRADIENT_MAX_STOPS   2
+
+/** Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
+ *  - 0:   round down,
+ *  - 64:  round up from x.75,
+ *  - 128: round up from half,
+ *  - 192: round up from x.25,
+ *  - 254: round up */
+#define LV_COLOR_MIX_ROUND_OFS  0
+
+/** Add 2 x 32-bit variables to each `lv_obj_t` to speed up getting style properties */
+#define LV_OBJ_STYLE_CACHE      0
+
+/** Add `id` field to `lv_obj_t` */
+#define LV_USE_OBJ_ID           0
+
+/**  Enable support widget names*/
+#define LV_USE_OBJ_NAME         0
+
+/** Automatically assign an ID when obj is created */
+#define LV_OBJ_ID_AUTO_ASSIGN   LV_USE_OBJ_ID
+
+/** Use builtin obj ID handler functions:
+* - lv_obj_assign_id:       Called when a widget is created. Use a separate counter for each widget class as an ID.
+* - lv_obj_id_compare:      Compare the ID to decide if it matches with a requested value.
+* - lv_obj_stringify_id:    Return string-ified identifier, e.g. "button3".
+* - lv_obj_free_id:         Does nothing, as there is no memory allocation for the ID.
+* When disabled these functions needs to be implemented by the user.*/
+#define LV_USE_OBJ_ID_BUILTIN   1
+
+/** Use obj property set/get API. */
+#define LV_USE_OBJ_PROPERTY 0
+
+/** Enable property name support. */
+#define LV_USE_OBJ_PROPERTY_NAME 1
+
+/* Enable the multi-touch gesture recognition feature */
+/* Gesture recognition requires the use of floats */
+#define LV_USE_GESTURE_RECOGNITION 0
+
+/*=====================
+ *  COMPILER SETTINGS
+ *====================*/
+
+/** For big endian systems set to 1 */
+#define LV_BIG_ENDIAN_SYSTEM 0
+
+/** Define a custom attribute for `lv_tick_inc` function */
+#define LV_ATTRIBUTE_TICK_INC
+
+/** Define a custom attribute for `lv_timer_handler` function */
+#define LV_ATTRIBUTE_TIMER_HANDLER
+
+/** Define a custom attribute for `lv_display_flush_ready` function */
+#define LV_ATTRIBUTE_FLUSH_READY
+
+/** Align VG_LITE buffers on this number of bytes.
+ *  @note  vglite_src_buf_aligned() uses this value to validate alignment of passed buffer pointers. */
+#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1
+
+/** Will be added where memory needs to be aligned (with -Os data might not be aligned to boundary by default).
+ *  E.g. __attribute__((aligned(4)))*/
+#define LV_ATTRIBUTE_MEM_ALIGN
+
+/** Attribute to mark large constant arrays, for example for font bitmaps */
+#define LV_ATTRIBUTE_LARGE_CONST
+
+/** Compiler prefix for a large array declaration in RAM */
+#define LV_ATTRIBUTE_LARGE_RAM_ARRAY
+
+/** Place performance critical functions into a faster memory (e.g RAM) */
+#define LV_ATTRIBUTE_FAST_MEM
+
+/** Export integer constant to binding. This macro is used with constants in the form of LV_<CONST> that
+ *  should also appear on LVGL binding API such as MicroPython. */
+#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning  /**< The default value just prevents GCC warning */
+
+/** Prefix all global extern data with this */
+#define LV_ATTRIBUTE_EXTERN_DATA
+
+/** Use `float` as `lv_value_precise_t` */
+#define LV_USE_FLOAT            0
+
+/** Enable matrix support
+ *  - Requires `LV_USE_FLOAT = 1` */
+#define LV_USE_MATRIX           0
+
+/** Include `lvgl_private.h` in `lvgl.h` to access internal data and functions by default */
+#ifndef LV_USE_PRIVATE_API
+    #define LV_USE_PRIVATE_API  0
+#endif
+
+/*==================
+ *   FONT USAGE
+ *===================*/
+
+/* Montserrat fonts with ASCII range and some symbols using bpp = 4
+ * https://fonts.google.com/specimen/Montserrat */
+#define LV_FONT_MONTSERRAT_8  0
+#define LV_FONT_MONTSERRAT_10 0
+#define LV_FONT_MONTSERRAT_12 0
+#define LV_FONT_MONTSERRAT_14 1
+#define LV_FONT_MONTSERRAT_16 0
+#define LV_FONT_MONTSERRAT_18 0
+#define LV_FONT_MONTSERRAT_20 0
+#define LV_FONT_MONTSERRAT_22 0
+#define LV_FONT_MONTSERRAT_24 0
+#define LV_FONT_MONTSERRAT_26 0
+#define LV_FONT_MONTSERRAT_28 0
+#define LV_FONT_MONTSERRAT_30 0
+#define LV_FONT_MONTSERRAT_32 0
+#define LV_FONT_MONTSERRAT_34 0
+#define LV_FONT_MONTSERRAT_36 0
+#define LV_FONT_MONTSERRAT_38 0
+#define LV_FONT_MONTSERRAT_40 0
+#define LV_FONT_MONTSERRAT_42 0
+#define LV_FONT_MONTSERRAT_44 0
+#define LV_FONT_MONTSERRAT_46 0
+#define LV_FONT_MONTSERRAT_48 0
+
+/* Demonstrate special features */
+#define LV_FONT_MONTSERRAT_28_COMPRESSED    0  /**< bpp = 3 */
+#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW    0  /**< Hebrew, Arabic, Persian letters and all their forms */
+#define LV_FONT_SOURCE_HAN_SANS_SC_14_CJK   0  /**< 1338 most common CJK radicals */
+#define LV_FONT_SOURCE_HAN_SANS_SC_16_CJK   0  /**< 1338 most common CJK radicals */
+
+/** Pixel perfect monospaced fonts */
+#define LV_FONT_UNSCII_8  0
+#define LV_FONT_UNSCII_16 0
+
+/** Optionally declare custom fonts here.
+ *
+ *  You can use any of these fonts as the default font too and they will be available
+ *  globally.  Example:
+ *
+ *  @code
+ *  #define LV_FONT_CUSTOM_DECLARE   LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)
+ *  @endcode
+ */
+#define LV_FONT_CUSTOM_DECLARE
+
+/** Always set a default font */
+#define LV_FONT_DEFAULT &lv_font_montserrat_14
+
+/** Enable handling large font and/or fonts with a lot of characters.
+ *  The limit depends on the font size, font face and bpp.
+ *  A compiler error will be triggered if a font needs it. */
+#define LV_FONT_FMT_TXT_LARGE 0
+
+/** Enables/disables support for compressed fonts. */
+#define LV_USE_FONT_COMPRESSED 0
+
+/** Enable drawing placeholders when glyph dsc is not found. */
+#define LV_USE_FONT_PLACEHOLDER 1
+
+/*=================
+ *  TEXT SETTINGS
+ *=================*/
+
+/**
+ * Select a character encoding for strings.
+ * Your IDE or editor should have the same character encoding.
+ * - LV_TXT_ENC_UTF8
+ * - LV_TXT_ENC_ASCII
+ */
+#define LV_TXT_ENC LV_TXT_ENC_UTF8
+
+/** While rendering text strings, break (wrap) text on these chars. */
+#define LV_TXT_BREAK_CHARS " ,.;:-_)]}"
+
+/** If a word is at least this long, will break wherever "prettiest".
+ *  To disable, set to a value <= 0. */
+#define LV_TXT_LINE_BREAK_LONG_LEN 0
+
+/** Minimum number of characters in a long word to put on a line before a break.
+ *  Depends on LV_TXT_LINE_BREAK_LONG_LEN. */
+#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3
+
+/** Minimum number of characters in a long word to put on a line after a break.
+ *  Depends on LV_TXT_LINE_BREAK_LONG_LEN. */
+#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
+
+/** Support bidirectional text. Allows mixing Left-to-Right and Right-to-Left text.
+ *  The direction will be processed according to the Unicode Bidirectional Algorithm:
+ *  https://www.w3.org/International/articles/inline-bidi-markup/uba-basics */
+#define LV_USE_BIDI 0
+#if LV_USE_BIDI
+    /*Set the default direction. Supported values:
+    *`LV_BASE_DIR_LTR` Left-to-Right
+    *`LV_BASE_DIR_RTL` Right-to-Left
+    *`LV_BASE_DIR_AUTO` detect text base direction*/
+    #define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
+#endif
+
+/** Enable Arabic/Persian processing
+ *  In these languages characters should be replaced with another form based on their position in the text */
+#define LV_USE_ARABIC_PERSIAN_CHARS 0
+
+/*The control character to use for signaling text recoloring*/
+#define LV_TXT_COLOR_CMD "#"
+
+/*==================
+ * WIDGETS
+ *================*/
+/* Documentation for widgets can be found here: https://docs.lvgl.io/master/details/widgets/index.html . */
+
+/** 1: Causes these widgets to be given default values at creation time.
+ *  - lv_buttonmatrix_t:  Get default maps:  {"Btn1", "Btn2", "Btn3", "\n", "Btn4", "Btn5", ""}, else map not set.
+ *  - lv_checkbox_t    :  String label set to "Check box", else set to empty string.
+ *  - lv_dropdown_t    :  Options set to "Option 1", "Option 2", "Option 3", else no values are set.
+ *  - lv_roller_t      :  Options set to "Option 1", "Option 2", "Option 3", "Option 4", "Option 5", else no values are set.
+ *  - lv_label_t       :  Text set to "Text", else empty string.
+ *  - lv_arclabel_t   :  Text set to "Arced Text", else empty string.
+ * */
+#define LV_WIDGETS_HAS_DEFAULT_VALUE  1
+
+#define LV_USE_ANIMIMG    1
+
+#define LV_USE_ARC        1
+
+#define LV_USE_ARCLABEL  1
+
+#define LV_USE_BAR        1
+
+#define LV_USE_BUTTON        1
+
+#define LV_USE_BUTTONMATRIX  1
+
+#define LV_USE_CALENDAR   1
+#if LV_USE_CALENDAR
+    #define LV_CALENDAR_WEEK_STARTS_MONDAY 0
+    #if LV_CALENDAR_WEEK_STARTS_MONDAY
+        #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
+    #else
+        #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
+    #endif
+
+    #define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
+    #define LV_USE_CALENDAR_HEADER_ARROW 1
+    #define LV_USE_CALENDAR_HEADER_DROPDOWN 1
+    #define LV_USE_CALENDAR_CHINESE 0
+#endif  /*LV_USE_CALENDAR*/
+
+#define LV_USE_CANVAS     1
+
+#define LV_USE_CHART      1
+
+#define LV_USE_CHECKBOX   1
+
+#define LV_USE_DROPDOWN   1   /**< Requires: lv_label */
+
+#define LV_USE_IMAGE      1   /**< Requires: lv_label */
+
+#define LV_USE_IMAGEBUTTON     1
+
+#define LV_USE_KEYBOARD   1
+
+#define LV_USE_LABEL      1
+#if LV_USE_LABEL
+    #define LV_LABEL_TEXT_SELECTION 1   /**< Enable selecting text of the label */
+    #define LV_LABEL_LONG_TXT_HINT 1    /**< Store some extra info in labels to speed up drawing of very long text */
+    #define LV_LABEL_WAIT_CHAR_COUNT 3  /**< The count of wait chart */
+#endif
+
+#define LV_USE_LED        1
+
+#define LV_USE_LINE       1
+
+#define LV_USE_LIST       1
+
+#define LV_USE_LOTTIE     0  /**< Requires: lv_canvas, thorvg */
+
+#define LV_USE_MENU       1
+
+#define LV_USE_MSGBOX     1
+
+#define LV_USE_ROLLER     1   /**< Requires: lv_label */
+
+#define LV_USE_SCALE      1
+
+#define LV_USE_SLIDER     1   /**< Requires: lv_bar */
+
+#define LV_USE_SPAN       1
+#if LV_USE_SPAN
+    /** A line of text can contain this maximum number of span descriptors. */
+    #define LV_SPAN_SNIPPET_STACK_SIZE 64
+#endif
+
+#define LV_USE_SPINBOX    1
+
+#define LV_USE_SPINNER    1
+
+#define LV_USE_SWITCH     1
+
+#define LV_USE_TABLE      1
+
+#define LV_USE_TABVIEW    1
+
+#define LV_USE_TEXTAREA   1   /**< Requires: lv_label */
+#if LV_USE_TEXTAREA != 0
+    #define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500    /**< [ms] */
+#endif
+
+#define LV_USE_TILEVIEW   1
+
+#define LV_USE_WIN        1
+
+#define LV_USE_3DTEXTURE  0
+
+/*==================
+ * THEMES
+ *==================*/
+/* Documentation for themes can be found here: https://docs.lvgl.io/master/details/common-widget-features/styles/styles.html#themes . */
+
+/** A simple, impressive and very complete theme */
+#define LV_USE_THEME_DEFAULT 1
+#if LV_USE_THEME_DEFAULT
+    /** 0: Light mode; 1: Dark mode */
+    #define LV_THEME_DEFAULT_DARK 0
+
+    /** 1: Enable grow on press */
+    #define LV_THEME_DEFAULT_GROW 1
+
+    /** Default transition time in ms. */
+    #define LV_THEME_DEFAULT_TRANSITION_TIME 80
+#endif /*LV_USE_THEME_DEFAULT*/
+
+/** A very simple theme that is a good starting point for a custom theme */
+#define LV_USE_THEME_SIMPLE 1
+
+/** A theme designed for monochrome displays */
+#define LV_USE_THEME_MONO 1
+
+/*==================
+ * LAYOUTS
+ *==================*/
+/* Documentation for layouts can be found here: https://docs.lvgl.io/master/details/common-widget-features/layouts/index.html . */
+
+/** A layout similar to Flexbox in CSS. */
+#define LV_USE_FLEX 1
+
+/** A layout similar to Grid in CSS. */
+#define LV_USE_GRID 1
+
+/*====================
+ * 3RD PARTS LIBRARIES
+ *====================*/
+/* Documentation for libraries can be found here: https://docs.lvgl.io/master/details/libs/index.html . */
+
+/* File system interfaces for common APIs */
+
+/** Setting a default driver letter allows skipping the driver prefix in filepaths.
+ *  Documentation about how to use the below driver-identifier letters can be found at
+ *  https://docs.lvgl.io/master/details/main-modules/fs.html#lv-fs-identifier-letters . */
+#define LV_FS_DEFAULT_DRIVER_LETTER '\0'
+
+/** API for fopen, fread, etc. */
+#define LV_USE_FS_STDIO 0
+#if LV_USE_FS_STDIO
+    #define LV_FS_STDIO_LETTER '\0'     /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_STDIO_PATH ""         /**< Set the working directory. File/directory paths will be appended to it. */
+    #define LV_FS_STDIO_CACHE_SIZE 0    /**< >0 to cache this number of bytes in lv_fs_read() */
+#endif
+
+/** API for open, read, etc. */
+#define LV_USE_FS_POSIX 0
+#if LV_USE_FS_POSIX
+    #define LV_FS_POSIX_LETTER '\0'     /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_POSIX_PATH ""         /**< Set the working directory. File/directory paths will be appended to it. */
+    #define LV_FS_POSIX_CACHE_SIZE 0    /**< >0 to cache this number of bytes in lv_fs_read() */
+#endif
+
+/** API for CreateFile, ReadFile, etc. */
+#define LV_USE_FS_WIN32 0
+#if LV_USE_FS_WIN32
+    #define LV_FS_WIN32_LETTER '\0'     /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_WIN32_PATH ""         /**< Set the working directory. File/directory paths will be appended to it. */
+    #define LV_FS_WIN32_CACHE_SIZE 0    /**< >0 to cache this number of bytes in lv_fs_read() */
+#endif
+
+/** API for FATFS (needs to be added separately). Uses f_open, f_read, etc. */
+#define LV_USE_FS_FATFS 0
+#if LV_USE_FS_FATFS
+    #define LV_FS_FATFS_LETTER '\0'     /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_FATFS_PATH ""         /**< Set the working directory. File/directory paths will be appended to it. */
+    #define LV_FS_FATFS_CACHE_SIZE 0    /**< >0 to cache this number of bytes in lv_fs_read() */
+#endif
+
+/** API for memory-mapped file access. */
+#define LV_USE_FS_MEMFS 0
+#if LV_USE_FS_MEMFS
+    #define LV_FS_MEMFS_LETTER '\0'     /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+#endif
+
+/** API for LittleFs. */
+#define LV_USE_FS_LITTLEFS 0
+#if LV_USE_FS_LITTLEFS
+    #define LV_FS_LITTLEFS_LETTER '\0'  /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_LITTLEFS_PATH ""      /**< Set the working directory. File/directory paths will be appended to it. */
+#endif
+
+/** API for Arduino LittleFs. */
+#define LV_USE_FS_ARDUINO_ESP_LITTLEFS 0
+#if LV_USE_FS_ARDUINO_ESP_LITTLEFS
+    #define LV_FS_ARDUINO_ESP_LITTLEFS_LETTER '\0'  /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_ARDUINO_ESP_LITTLEFS_PATH ""      /**< Set the working directory. File/directory paths will be appended to it. */
+#endif
+
+/** API for Arduino Sd. */
+#define LV_USE_FS_ARDUINO_SD 0
+#if LV_USE_FS_ARDUINO_SD
+    #define LV_FS_ARDUINO_SD_LETTER '\0'  /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+    #define LV_FS_ARDUINO_SD_PATH ""      /**< Set the working directory. File/directory paths will be appended to it. */
+#endif
+
+/** API for UEFI */
+#define LV_USE_FS_UEFI 0
+#if LV_USE_FS_UEFI
+    #define LV_FS_UEFI_LETTER '\0'      /**< Set an upper-case driver-identifier letter for this driver (e.g. 'A'). */
+#endif
+
+#define LV_USE_FS_FROGFS 0
+#if LV_USE_FS_FROGFS
+    #define LV_FS_FROGFS_LETTER '\0'
+#endif
+
+/** LODEPNG decoder library */
+#define LV_USE_LODEPNG 0
+
+/** PNG decoder(libpng) library */
+#define LV_USE_LIBPNG 0
+
+/** BMP decoder library */
+#define LV_USE_BMP 0
+
+/** JPG + split JPG decoder library.
+ *  Split JPG is a custom format optimized for embedded systems. */
+#define LV_USE_TJPGD 0
+
+/** libjpeg-turbo decoder library.
+ *  - Supports complete JPEG specifications and high-performance JPEG decoding. */
+#define LV_USE_LIBJPEG_TURBO 0
+
+/** GIF decoder library */
+#define LV_USE_GIF 0
+#if LV_USE_GIF
+    /** GIF decoder accelerate */
+    #define LV_GIF_CACHE_DECODE_DATA 0
+#endif
+
+/** GStreamer library */
+#define LV_USE_GSTREAMER 0
+
+/** Decode bin images to RAM */
+#define LV_BIN_DECODER_RAM_LOAD 0
+
+/** RLE decompress library */
+#define LV_USE_RLE 0
+
+/** QR code library */
+#define LV_USE_QRCODE 0
+
+/** Barcode code library */
+#define LV_USE_BARCODE 0
+
+/** FreeType library */
+#define LV_USE_FREETYPE 0
+#if LV_USE_FREETYPE
+    /** Let FreeType use LVGL memory and file porting */
+    #define LV_FREETYPE_USE_LVGL_PORT 0
+
+    /** Cache count of glyphs in FreeType, i.e. number of glyphs that can be cached.
+     *  The higher the value, the more memory will be used. */
+    #define LV_FREETYPE_CACHE_FT_GLYPH_CNT 256
+#endif
+
+/** Built-in TTF decoder */
+#define LV_USE_TINY_TTF 0
+#if LV_USE_TINY_TTF
+    /* Enable loading TTF data from files */
+    #define LV_TINY_TTF_FILE_SUPPORT 0
+    #define LV_TINY_TTF_CACHE_GLYPH_CNT 128
+    #define LV_TINY_TTF_CACHE_KERNING_CNT 256
+#endif
+
+/** Rlottie library */
+#define LV_USE_RLOTTIE 0
+
+/** Requires `LV_USE_3DTEXTURE = 1` */
+#define LV_USE_GLTF  0
+
+/** Enable Vector Graphic APIs
+ *  Requires `LV_USE_MATRIX = 1` */
+#define LV_USE_VECTOR_GRAPHIC  0
+
+/** Enable ThorVG (vector graphics library) from the src/libs folder.
+ *  Requires LV_USE_VECTOR_GRAPHIC */
+#define LV_USE_THORVG_INTERNAL 0
+
+/** Enable ThorVG by assuming that its installed and linked to the project
+ *  Requires LV_USE_VECTOR_GRAPHIC */
+#define LV_USE_THORVG_EXTERNAL 0
+
+/** Use lvgl built-in LZ4 lib */
+#define LV_USE_LZ4_INTERNAL  0
+
+/** Use external LZ4 library */
+#define LV_USE_LZ4_EXTERNAL  0
+
+/*SVG library
+ *  - Requires `LV_USE_VECTOR_GRAPHIC = 1` */
+#define LV_USE_SVG 0
+#define LV_USE_SVG_ANIMATION 0
+#define LV_USE_SVG_DEBUG 0
+
+/** FFmpeg library for image decoding and playing videos.
+ *  Supports all major image formats so do not enable other image decoder with it. */
+#define LV_USE_FFMPEG 0
+#if LV_USE_FFMPEG
+    /** Dump input information to stderr */
+    #define LV_FFMPEG_DUMP_FORMAT 0
+    /** Use lvgl file path in FFmpeg Player widget
+     *  You won't be able to open URLs after enabling this feature.
+     *  Note that FFmpeg image decoder will always use lvgl file system. */
+    #define LV_FFMPEG_PLAYER_USE_LV_FS 0
+#endif
+
+/*==================
+ * OTHERS
+ *==================*/
+/* Documentation for several of the below items can be found here: https://docs.lvgl.io/master/details/auxiliary-modules/index.html . */
+
+/** 1: Enable API to take snapshot for object */
+#define LV_USE_SNAPSHOT 0
+
+/** 1: Enable system monitor component */
+#define LV_USE_SYSMON   0
+#if LV_USE_SYSMON
+    /** Get the idle percentage. E.g. uint32_t my_get_idle(void); */
+    #define LV_SYSMON_GET_IDLE lv_os_get_idle_percent
+    /** 1: Enable usage of lv_os_get_proc_idle_percent.*/
+    #define LV_SYSMON_PROC_IDLE_AVAILABLE 0
+    #if LV_SYSMON_PROC_IDLE_AVAILABLE
+        /** Get the applications idle percentage.
+         * - Requires `LV_USE_OS == LV_OS_PTHREAD` */
+        #define LV_SYSMON_GET_PROC_IDLE lv_os_get_proc_idle_percent
+    #endif
+
+    /** 1: Show CPU usage and FPS count.
+     *  - Requires `LV_USE_SYSMON = 1` */
+    #define LV_USE_PERF_MONITOR 0
+    #if LV_USE_PERF_MONITOR
+        #define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
+
+        /** 0: Displays performance data on the screen; 1: Prints performance data using log. */
+        #define LV_USE_PERF_MONITOR_LOG_MODE 0
+    #endif
+
+    /** 1: Show used memory and memory fragmentation.
+     *     - Requires `LV_USE_STDLIB_MALLOC = LV_STDLIB_BUILTIN`
+     *     - Requires `LV_USE_SYSMON = 1`*/
+    #define LV_USE_MEM_MONITOR 0
+    #if LV_USE_MEM_MONITOR
+        #define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT
+    #endif
+#endif /*LV_USE_SYSMON*/
+
+/** 1: Enable runtime performance profiler */
+#define LV_USE_PROFILER 0
+#if LV_USE_PROFILER
+    /** 1: Enable the built-in profiler */
+    #define LV_USE_PROFILER_BUILTIN 1
+    #if LV_USE_PROFILER_BUILTIN
+        /** Default profiler trace buffer size */
+        #define LV_PROFILER_BUILTIN_BUF_SIZE (16 * 1024)     /**< [bytes] */
+        #define LV_PROFILER_BUILTIN_DEFAULT_ENABLE 1
+        #define LV_USE_PROFILER_BUILTIN_POSIX 0 /**< Enable POSIX profiler port */
+    #endif
+
+    /** Header to include for profiler */
+    #define LV_PROFILER_INCLUDE "lvgl/src/misc/lv_profiler_builtin.h"
+
+    /** Profiler start point function */
+    #define LV_PROFILER_BEGIN    LV_PROFILER_BUILTIN_BEGIN
+
+    /** Profiler end point function */
+    #define LV_PROFILER_END      LV_PROFILER_BUILTIN_END
+
+    /** Profiler start point function with custom tag */
+    #define LV_PROFILER_BEGIN_TAG LV_PROFILER_BUILTIN_BEGIN_TAG
+
+    /** Profiler end point function with custom tag */
+    #define LV_PROFILER_END_TAG   LV_PROFILER_BUILTIN_END_TAG
+
+    /*Enable layout profiler*/
+    #define LV_PROFILER_LAYOUT 1
+
+    /*Enable disp refr profiler*/
+    #define LV_PROFILER_REFR 1
+
+    /*Enable draw profiler*/
+    #define LV_PROFILER_DRAW 1
+
+    /*Enable indev profiler*/
+    #define LV_PROFILER_INDEV 1
+
+    /*Enable decoder profiler*/
+    #define LV_PROFILER_DECODER 1
+
+    /*Enable font profiler*/
+    #define LV_PROFILER_FONT 1
+
+    /*Enable fs profiler*/
+    #define LV_PROFILER_FS 1
+
+    /*Enable style profiler*/
+    #define LV_PROFILER_STYLE 0
+
+    /*Enable timer profiler*/
+    #define LV_PROFILER_TIMER 1
+
+    /*Enable cache profiler*/
+    #define LV_PROFILER_CACHE 1
+
+    /*Enable event profiler*/
+    #define LV_PROFILER_EVENT 1
+#endif
+
+/** 1: Enable Monkey test */
+#define LV_USE_MONKEY 0
+
+/** 1: Enable grid navigation */
+#define LV_USE_GRIDNAV 0
+
+/** 1: Enable `lv_obj` fragment logic */
+#define LV_USE_FRAGMENT 0
+
+/** 1: Support using images as font in label or span widgets */
+#define LV_USE_IMGFONT 0
+
+/** 1: Enable an observer pattern implementation */
+#define LV_USE_OBSERVER 1
+
+/** 1: Enable Pinyin input method
+ *  - Requires: lv_keyboard */
+#define LV_USE_IME_PINYIN 0
+#if LV_USE_IME_PINYIN
+    /** 1: Use default thesaurus.
+     *  @note  If you do not use the default thesaurus, be sure to use `lv_ime_pinyin` after setting the thesaurus. */
+    #define LV_IME_PINYIN_USE_DEFAULT_DICT 1
+    /** Set maximum number of candidate panels that can be displayed.
+     *  @note  This needs to be adjusted according to size of screen. */
+    #define LV_IME_PINYIN_CAND_TEXT_NUM 6
+
+    /** Use 9-key input (k9). */
+    #define LV_IME_PINYIN_USE_K9_MODE      1
+    #if LV_IME_PINYIN_USE_K9_MODE == 1
+        #define LV_IME_PINYIN_K9_CAND_TEXT_NUM 3
+    #endif /*LV_IME_PINYIN_USE_K9_MODE*/
+#endif
+
+/** 1: Enable file explorer.
+ *  - Requires: lv_table */
+#define LV_USE_FILE_EXPLORER                     0
+#if LV_USE_FILE_EXPLORER
+    /** Maximum length of path */
+    #define LV_FILE_EXPLORER_PATH_MAX_LEN        (128)
+    /** Quick access bar, 1:use, 0:do not use.
+     *  - Requires: lv_list */
+    #define LV_FILE_EXPLORER_QUICK_ACCESS        1
+#endif
+
+/** 1: Enable Font manager */
+#define LV_USE_FONT_MANAGER                     0
+#if LV_USE_FONT_MANAGER
+
+/**Font manager name max length*/
+#define LV_FONT_MANAGER_NAME_MAX_LEN            32
+
+#endif
+
+/** Enable emulated input devices, time emulation, and screenshot compares. */
+#define LV_USE_TEST 0
+#if LV_USE_TEST
+
+/** Enable `lv_test_screenshot_compare`.
+ * Requires lodepng and a few MB of extra RAM. */
+#define LV_USE_TEST_SCREENSHOT_COMPARE 0
+#endif /*LV_USE_TEST*/
+
+/** Enable loading XML UIs runtime */
+#define LV_USE_XML    0
+
+/** 1: Enable text translation support */
+#define LV_USE_TRANSLATION 0
+
+/*1: Enable color filter style*/
+#define LV_USE_COLOR_FILTER     0
+
+/*==================
+ * DEVICES
+ *==================*/
+
+/** Use SDL to open window on PC and handle mouse and keyboard. */
+#define LV_USE_SDL              0
+#if LV_USE_SDL
+    #define LV_SDL_INCLUDE_PATH     <SDL2/SDL.h>
+    #define LV_SDL_RENDER_MODE      LV_DISPLAY_RENDER_MODE_DIRECT   /**< LV_DISPLAY_RENDER_MODE_DIRECT is recommended for best performance */
+    #define LV_SDL_BUF_COUNT        1    /**< 1 or 2 */
+    #define LV_SDL_ACCELERATED      1    /**< 1: Use hardware acceleration*/
+    #define LV_SDL_FULLSCREEN       0    /**< 1: Make the window full screen by default */
+    #define LV_SDL_DIRECT_EXIT      1    /**< 1: Exit the application when all SDL windows are closed */
+    #define LV_SDL_MOUSEWHEEL_MODE  LV_SDL_MOUSEWHEEL_MODE_ENCODER  /*LV_SDL_MOUSEWHEEL_MODE_ENCODER/CROWN*/
+#endif
+
+/** Use X11 to open window on Linux desktop and handle mouse and keyboard */
+#define LV_USE_X11              0
+#if LV_USE_X11
+    #define LV_X11_DIRECT_EXIT         1  /**< Exit application when all X11 windows have been closed */
+    #define LV_X11_DOUBLE_BUFFER       1  /**< Use double buffers for rendering */
+    /* Select only 1 of the following render modes (LV_X11_RENDER_MODE_PARTIAL preferred!). */
+    #define LV_X11_RENDER_MODE_PARTIAL 1  /**< Partial render mode (preferred) */
+    #define LV_X11_RENDER_MODE_DIRECT  0  /**< Direct render mode */
+    #define LV_X11_RENDER_MODE_FULL    0  /**< Full render mode */
+#endif
+
+/** Use Wayland to open a window and handle input on Linux or BSD desktops */
+#define LV_USE_WAYLAND          0
+#if LV_USE_WAYLAND
+    #define LV_WAYLAND_BUF_COUNT            1    /**< Use 1 for single buffer with partial render mode or 2 for double buffer with full render mode*/
+    #define LV_WAYLAND_USE_DMABUF           0    /**< Use DMA buffers for frame buffers. Requires LV_DRAW_USE_G2D */
+    #define LV_WAYLAND_RENDER_MODE          LV_DISPLAY_RENDER_MODE_PARTIAL   /**< DMABUF supports LV_DISPLAY_RENDER_MODE_FULL and LV_DISPLAY_RENDER_MODE_DIRECT*/
+                                                                             /**< When LV_WAYLAND_USE_DMABUF is disabled, only LV_DISPLAY_RENDER_MODE_PARTIAL is supported*/
+    #define LV_WAYLAND_WINDOW_DECORATIONS   0    /**< Draw client side window decorations only necessary on Mutter/GNOME. Not supported using DMABUF*/
+#endif
+
+/** Driver for /dev/fb */
+#define LV_USE_LINUX_FBDEV      0
+#if LV_USE_LINUX_FBDEV
+    #define LV_LINUX_FBDEV_BSD           0
+    #define LV_LINUX_FBDEV_RENDER_MODE   LV_DISPLAY_RENDER_MODE_PARTIAL
+    #define LV_LINUX_FBDEV_BUFFER_COUNT  0
+    #define LV_LINUX_FBDEV_BUFFER_SIZE   60
+    #define LV_LINUX_FBDEV_MMAP          1
+#endif
+
+/** Use Nuttx to open window and handle touchscreen */
+#define LV_USE_NUTTX    0
+
+#if LV_USE_NUTTX
+    #define LV_USE_NUTTX_INDEPENDENT_IMAGE_HEAP 0
+
+    /** Use independent image heap for default draw buffer */
+    #define LV_NUTTX_DEFAULT_DRAW_BUF_USE_INDEPENDENT_IMAGE_HEAP    0
+
+    #define LV_USE_NUTTX_LIBUV    0
+
+    /** Use Nuttx custom init API to open window and handle touchscreen */
+    #define LV_USE_NUTTX_CUSTOM_INIT    0
+
+    /** Driver for /dev/lcd */
+    #define LV_USE_NUTTX_LCD      0
+    #if LV_USE_NUTTX_LCD
+        #define LV_NUTTX_LCD_BUFFER_COUNT    0
+        #define LV_NUTTX_LCD_BUFFER_SIZE     60
+    #endif
+
+    /** Driver for /dev/input */
+    #define LV_USE_NUTTX_TOUCHSCREEN    0
+
+    /** Touchscreen cursor size in pixels(<=0: disable cursor) */
+    #define LV_NUTTX_TOUCHSCREEN_CURSOR_SIZE    0
+
+    /** Driver for /dev/mouse */
+    #define LV_USE_NUTTX_MOUSE    0
+
+    /** Mouse movement step (pixels) */
+    #define LV_USE_NUTTX_MOUSE_MOVE_STEP    1
+
+    /*NuttX trace file and its path*/
+    #define LV_USE_NUTTX_TRACE_FILE 0
+    #if LV_USE_NUTTX_TRACE_FILE
+        #define LV_NUTTX_TRACE_FILE_PATH "/data/lvgl-trace.log"
+    #endif
+
+#endif
+
+/** Driver for /dev/dri/card */
+#define LV_USE_LINUX_DRM        0
+
+#if LV_USE_LINUX_DRM
+
+    /* Use the MESA GBM library to allocate DMA buffers that can be
+     * shared across sub-systems and libraries using the Linux DMA-BUF API.
+     * The GBM library aims to provide a platform independent memory management system
+     * it supports the major GPU vendors - This option requires linking with libgbm */
+    #define LV_USE_LINUX_DRM_GBM_BUFFERS 0
+
+    #define LV_LINUX_DRM_USE_EGL     0
+#endif
+
+/** Interface for TFT_eSPI */
+#define LV_USE_TFT_ESPI         0
+
+/** Interface for Lovyan_GFX */
+#define LV_USE_LOVYAN_GFX         0
+
+#if LV_USE_LOVYAN_GFX
+    #define LV_LGFX_USER_INCLUDE "lv_lgfx_user.hpp"
+
+#endif /*LV_USE_LOVYAN_GFX*/
+
+/** Driver for evdev input devices */
+#define LV_USE_EVDEV    0
+
+/** Driver for libinput input devices */
+#define LV_USE_LIBINPUT    0
+
+#if LV_USE_LIBINPUT
+    #define LV_LIBINPUT_BSD    0
+
+    /** Full keyboard support */
+    #define LV_LIBINPUT_XKB             0
+    #if LV_LIBINPUT_XKB
+        /** "setxkbmap -query" can help find the right values for your keyboard */
+        #define LV_LIBINPUT_XKB_KEY_MAP { .rules = NULL, .model = "pc101", .layout = "us", .variant = NULL, .options = NULL }
+    #endif
+#endif
+
+/* Drivers for LCD devices connected via SPI/parallel port */
+#define LV_USE_ST7735        0
+#define LV_USE_ST7789        0
+#define LV_USE_ST7796        0
+#define LV_USE_ILI9341       0
+#define LV_USE_FT81X         0
+#define LV_USE_NV3007        0
+
+#if (LV_USE_ST7735 | LV_USE_ST7789 | LV_USE_ST7796 | LV_USE_ILI9341 | LV_USE_NV3007)
+    #define LV_USE_GENERIC_MIPI 1
+#else
+    #define LV_USE_GENERIC_MIPI 0
+#endif
+
+/** Driver for Renesas GLCD */
+#define LV_USE_RENESAS_GLCDC    0
+
+/** Driver for ST LTDC */
+#define LV_USE_ST_LTDC    0
+#if LV_USE_ST_LTDC
+    /* Only used for partial. */
+    #define LV_ST_LTDC_USE_DMA2D_FLUSH 0
+#endif
+
+/** Driver for NXP ELCDIF */
+#define LV_USE_NXP_ELCDIF   0
+
+/** LVGL Windows backend */
+#define LV_USE_WINDOWS    0
+
+/** LVGL UEFI backend */
+#define LV_USE_UEFI 0
+#if LV_USE_UEFI
+    #define LV_USE_UEFI_INCLUDE "myefi.h"   /**< Header that hides the actual framework (EDK2, gnu-efi, ...) */
+    #define LV_UEFI_USE_MEMORY_SERVICES 0   /**< Use the memory functions from the boot services table */
+#endif
+
+/** Use a generic OpenGL driver that can be used to embed in other applications or used with GLFW/EGL */
+#define LV_USE_OPENGLES   0
+#if LV_USE_OPENGLES
+    #define LV_USE_OPENGLES_DEBUG        1    /**< Enable or disable debug for opengles */
+#endif
+
+/** Use GLFW to open window on PC and handle mouse and keyboard. Requires*/
+#define LV_USE_GLFW   0
+
+
+/** QNX Screen display and input drivers */
+#define LV_USE_QNX              0
+#if LV_USE_QNX
+    #define LV_QNX_BUF_COUNT        1    /**< 1 or 2 */
+#endif
+
+/*=====================
+* BUILD OPTIONS
+*======================*/
+
+/** Enable examples to be built with the library. */
+#define LV_BUILD_EXAMPLES 1
+
+/** Build the demos */
+#define LV_BUILD_DEMOS 1
+
+/*===================
+ * DEMO USAGE
+ ====================*/
+
+#if LV_BUILD_DEMOS
+    /** Show some widgets. This might be required to increase `LV_MEM_SIZE`. */
+    #define LV_USE_DEMO_WIDGETS 0
+
+    /** Demonstrate usage of encoder and keyboard. */
+    #define LV_USE_DEMO_KEYPAD_AND_ENCODER 0
+
+    /** Benchmark your system */
+    #define LV_USE_DEMO_BENCHMARK 0
+
+    #if LV_USE_DEMO_BENCHMARK
+        /** Use fonts where bitmaps are aligned 16 byte and has Nx16 byte stride */
+        #define LV_DEMO_BENCHMARK_ALIGNED_FONTS 0
+    #endif
+
+    /** Render test for each primitive.
+     *  - Requires at least 480x272 display. */
+    #define LV_USE_DEMO_RENDER 0
+
+    /** Stress test for LVGL */
+    #define LV_USE_DEMO_STRESS 0
+
+    /** Music player demo */
+    #define LV_USE_DEMO_MUSIC 0
+    #if LV_USE_DEMO_MUSIC
+        #define LV_DEMO_MUSIC_SQUARE    0
+        #define LV_DEMO_MUSIC_LANDSCAPE 0
+        #define LV_DEMO_MUSIC_ROUND     0
+        #define LV_DEMO_MUSIC_LARGE     0
+        #define LV_DEMO_MUSIC_AUTO_PLAY 0
+    #endif
+
+    /** Vector graphic demo */
+    #define LV_USE_DEMO_VECTOR_GRAPHIC  0
+
+    /** GLTF demo */
+    #define LV_USE_DEMO_GLTF            0
+
+    /*---------------------------
+     * Demos from lvgl/lv_demos
+      ---------------------------*/
+
+    /** Flex layout demo */
+    #define LV_USE_DEMO_FLEX_LAYOUT     0
+
+    /** Smart-phone like multi-language demo */
+    #define LV_USE_DEMO_MULTILANG       0
+
+    /** Widget transformation demo */
+    #define LV_USE_DEMO_TRANSFORM       0
+
+    /** Demonstrate scroll settings */
+    #define LV_USE_DEMO_SCROLL          0
+
+    /*E-bike demo with Lottie animations (if LV_USE_LOTTIE is enabled)*/
+    #define LV_USE_DEMO_EBIKE           0
+    #if LV_USE_DEMO_EBIKE
+        #define LV_DEMO_EBIKE_PORTRAIT  0    /*0: for 480x270..480x320, 1: for 480x800..720x1280*/
+    #endif
+
+    /** High-resolution demo */
+    #define LV_USE_DEMO_HIGH_RES        0
+
+    /* Smart watch demo */
+    #define LV_USE_DEMO_SMARTWATCH      0
+#endif /* LV_BUILD_DEMOS */
+
+/*--END OF LV_CONF_H--*/
+
+#endif /*LV_CONF_H*/
+
+#endif /*End of "Content enable"*/

components/easylvgl/lvgl9/lv_version.h

@@ -0,0 +1,17 @@
+/**
+ * @file lv_version.h
+ * The current version of LVGL
+ */
+
+#ifndef LV_VERSION_H
+#define LV_VERSION_H
+
+#define LVGL_VERSION_MAJOR 9
+#define LVGL_VERSION_MINOR 4
+#define LVGL_VERSION_PATCH 0
+#define LVGL_VERSION_INFO ""
+
+#endif /* LV_VERSION_H */
+
+
+

components/easylvgl/lvgl9/lvgl.h

@@ -0,0 +1,218 @@
+/**
+ * @file lvgl.h
+ * Include all LVGL related headers
+ */
+
+#ifndef LVGL_H
+#define LVGL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************
+ * CURRENT VERSION OF LVGL
+ ***************************/
+#include "lv_version.h"
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "src/lv_init.h"
+
+#include "src/stdlib/lv_mem.h"
+#include "src/stdlib/lv_string.h"
+#include "src/stdlib/lv_sprintf.h"
+
+#include "src/misc/lv_log.h"
+#include "src/misc/lv_timer.h"
+#include "src/misc/lv_math.h"
+#include "src/misc/lv_array.h"
+#include "src/misc/lv_async.h"
+#include "src/misc/lv_anim_timeline.h"
+#include "src/misc/lv_profiler_builtin.h"
+#include "src/misc/lv_rb.h"
+#include "src/misc/lv_utils.h"
+#include "src/misc/lv_iter.h"
+#include "src/misc/lv_circle_buf.h"
+#include "src/misc/lv_tree.h"
+
+#include "src/osal/lv_os.h"
+
+#include "src/tick/lv_tick.h"
+
+#include "src/core/lv_obj.h"
+#include "src/core/lv_group.h"
+#include "src/indev/lv_indev.h"
+#include "src/indev/lv_indev_gesture.h"
+#include "src/core/lv_refr.h"
+#include "src/display/lv_display.h"
+
+#include "src/font/lv_font.h"
+#include "src/font/lv_binfont_loader.h"
+#include "src/font/lv_font_fmt_txt.h"
+
+#include "src/widgets/animimage/lv_animimage.h"
+#include "src/widgets/arc/lv_arc.h"
+#include "src/widgets/arclabel/lv_arclabel.h"
+#include "src/widgets/bar/lv_bar.h"
+#include "src/widgets/button/lv_button.h"
+#include "src/widgets/buttonmatrix/lv_buttonmatrix.h"
+#include "src/widgets/calendar/lv_calendar.h"
+#include "src/widgets/canvas/lv_canvas.h"
+#include "src/widgets/chart/lv_chart.h"
+#include "src/widgets/checkbox/lv_checkbox.h"
+#include "src/widgets/dropdown/lv_dropdown.h"
+#include "src/widgets/image/lv_image.h"
+#include "src/widgets/imagebutton/lv_imagebutton.h"
+#include "src/widgets/keyboard/lv_keyboard.h"
+#include "src/widgets/label/lv_label.h"
+#include "src/widgets/led/lv_led.h"
+#include "src/widgets/line/lv_line.h"
+#include "src/widgets/list/lv_list.h"
+#include "src/widgets/lottie/lv_lottie.h"
+#include "src/widgets/menu/lv_menu.h"
+#include "src/widgets/msgbox/lv_msgbox.h"
+#include "src/widgets/roller/lv_roller.h"
+#include "src/widgets/scale/lv_scale.h"
+#include "src/widgets/slider/lv_slider.h"
+#include "src/widgets/span/lv_span.h"
+#include "src/widgets/spinbox/lv_spinbox.h"
+#include "src/widgets/spinner/lv_spinner.h"
+#include "src/widgets/switch/lv_switch.h"
+#include "src/widgets/table/lv_table.h"
+#include "src/widgets/tabview/lv_tabview.h"
+#include "src/widgets/textarea/lv_textarea.h"
+#include "src/widgets/tileview/lv_tileview.h"
+#include "src/widgets/win/lv_win.h"
+#include "src/widgets/3dtexture/lv_3dtexture.h"
+
+#include "src/others/snapshot/lv_snapshot.h"
+#include "src/others/sysmon/lv_sysmon.h"
+#include "src/others/monkey/lv_monkey.h"
+#include "src/others/gridnav/lv_gridnav.h"
+#include "src/others/fragment/lv_fragment.h"
+#include "src/others/imgfont/lv_imgfont.h"
+#include "src/others/observer/lv_observer.h"
+#include "src/others/ime/lv_ime_pinyin.h"
+#include "src/others/file_explorer/lv_file_explorer.h"
+#include "src/others/font_manager/lv_font_manager.h"
+#include "src/others/translation/lv_translation.h"
+#include "src/others/xml/lv_xml.h"
+#include "src/others/test/lv_test.h"
+
+#include "src/libs/barcode/lv_barcode.h"
+#include "src/libs/bin_decoder/lv_bin_decoder.h"
+#include "src/libs/bmp/lv_bmp.h"
+#include "src/libs/rle/lv_rle.h"
+#include "src/libs/fsdrv/lv_fsdrv.h"
+#include "src/libs/lodepng/lv_lodepng.h"
+#include "src/libs/libpng/lv_libpng.h"
+#include "src/libs/gltf/gltf_data/lv_gltf_model.h"
+#include "src/libs/gltf/gltf_view/lv_gltf.h"
+#include "src/libs/gif/lv_gif.h"
+#include "src/libs/gstreamer/lv_gstreamer.h"
+#include "src/libs/qrcode/lv_qrcode.h"
+#include "src/libs/tjpgd/lv_tjpgd.h"
+#include "src/libs/libjpeg_turbo/lv_libjpeg_turbo.h"
+#include "src/libs/freetype/lv_freetype.h"
+#include "src/libs/rlottie/lv_rlottie.h"
+#include "src/libs/ffmpeg/lv_ffmpeg.h"
+#include "src/libs/tiny_ttf/lv_tiny_ttf.h"
+#include "src/libs/svg/lv_svg.h"
+#include "src/libs/svg/lv_svg_render.h"
+
+#include "src/layouts/lv_layout.h"
+
+#include "src/draw/lv_draw_buf.h"
+#include "src/draw/lv_draw_vector.h"
+#include "src/draw/sw/lv_draw_sw_utils.h"
+#include "src/draw/eve/lv_draw_eve_target.h"
+
+#include "src/themes/lv_theme.h"
+
+#include "src/drivers/lv_drivers.h"
+
+/* Define LV_DISABLE_API_MAPPING using a compiler option 
+ * to make sure your application is not using deprecated names */
+#ifndef LV_DISABLE_API_MAPPING
+    #include "src/lv_api_map_v8.h"
+    #include "src/lv_api_map_v9_0.h"
+    #include "src/lv_api_map_v9_1.h"
+    #include "src/lv_api_map_v9_2.h"
+    #include "src/lv_api_map_v9_3.h"
+#endif /*LV_DISABLE_API_MAPPING*/
+
+#if LV_USE_PRIVATE_API
+#include "src/lvgl_private.h"
+#endif
+
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/** Gives 1 if the x.y.z version is supported in the current version
+ * Usage:
+ *
+ * - Require v6
+ * #if LV_VERSION_CHECK(6,0,0)
+ *   new_func_in_v6();
+ * #endif
+ *
+ *
+ * - Require at least v5.3
+ * #if LV_VERSION_CHECK(5,3,0)
+ *   new_feature_from_v5_3();
+ * #endif
+ *
+ *
+ * - Require v5.3.2 bugfixes
+ * #if LV_VERSION_CHECK(5,3,2)
+ *   bugfix_in_v5_3_2();
+ * #endif
+ *
+ */
+#define LV_VERSION_CHECK(x,y,z) (x == LVGL_VERSION_MAJOR && (y < LVGL_VERSION_MINOR || (y == LVGL_VERSION_MINOR && z <= LVGL_VERSION_PATCH)))
+
+/**
+ * Wrapper functions for VERSION macros
+ */
+
+static inline int lv_version_major(void)
+{
+    return LVGL_VERSION_MAJOR;
+}
+
+static inline int lv_version_minor(void)
+{
+    return LVGL_VERSION_MINOR;
+}
+
+static inline int lv_version_patch(void)
+{
+    return LVGL_VERSION_PATCH;
+}
+
+static inline const char * lv_version_info(void)
+{
+    return LVGL_VERSION_INFO;
+}
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LVGL_H*/

components/easylvgl/lvgl9/src/core/lv_global.h

@@ -0,0 +1,318 @@
+/**
+ * @file lv_global.h
+ *
+ */
+
+#ifndef LV_GLOBAL_H
+#define LV_GLOBAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#include "../misc/lv_types.h"
+#include "../draw/lv_draw.h"
+#if LV_USE_DRAW_SW
+#include "../draw/sw/lv_draw_sw.h"
+#endif
+#include "../misc/lv_anim.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_color_op.h"
+#include "../misc/lv_ll.h"
+#include "../misc/lv_log.h"
+#include "../misc/lv_style.h"
+#include "../misc/lv_timer.h"
+#include "../osal/lv_os_private.h"
+#include "../others/sysmon/lv_sysmon.h"
+#include "../stdlib/builtin/lv_tlsf.h"
+
+#if LV_USE_FONT_COMPRESSED
+#include "../font/lv_font_fmt_txt_private.h"
+#endif
+
+#include "../tick/lv_tick.h"
+#include "../layouts/lv_layout.h"
+
+#include "../misc/lv_types.h"
+
+#include "../misc/lv_timer_private.h"
+#include "../misc/lv_anim_private.h"
+#include "../tick/lv_tick_private.h"
+#include "../draw/lv_draw_buf_private.h"
+#include "../draw/lv_draw_private.h"
+#include "../draw/sw/lv_draw_sw_private.h"
+#include "../draw/sw/lv_draw_sw_mask_private.h"
+#include "../stdlib/builtin/lv_tlsf_private.h"
+#include "../others/sysmon/lv_sysmon_private.h"
+#include "../others/test/lv_test_private.h"
+#include "../layouts/lv_layout_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define ZERO_MEM_SENTINEL  0xa1b2c3d4
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+#if LV_USE_SPAN != 0
+struct _snippet_stack;
+#endif
+
+#if LV_USE_FREETYPE
+struct _lv_freetype_context_t;
+#endif
+
+#if LV_USE_PROFILER && LV_USE_PROFILER_BUILTIN
+struct _lv_profiler_builtin_ctx_t;
+#endif
+
+#if LV_USE_NUTTX
+struct _lv_nuttx_ctx_t;
+#endif
+
+typedef struct _lv_global_t {
+    /**
+     * User data for the LVGL library. Move from the bottom of the struct
+     * to avoid breaking the ABI. E.g., if the user data is used by a
+     * closed-source library, this can help to avoid re-compiling the library
+     * when the lvgl-related configs are changed.
+     */
+    void * user_data;
+
+    bool inited;
+    bool deinit_in_progress;     /**< Can be used e.g. in the LV_EVENT_DELETE to deinit the drivers too */
+
+    lv_ll_t disp_ll;
+    lv_display_t * disp_refresh;
+    lv_display_t * disp_default;
+
+    lv_ll_t style_trans_ll;
+    bool style_refresh;
+    uint32_t style_custom_table_size;
+    uint32_t style_last_custom_prop_id;
+    uint8_t * style_custom_prop_flag_lookup_table;
+
+    lv_ll_t group_ll;
+    lv_group_t * group_default;
+
+    lv_ll_t indev_ll;
+    lv_indev_t * indev_active;
+    lv_obj_t * indev_obj_active;
+
+    uint32_t layout_count;
+    lv_layout_dsc_t * layout_list;
+    bool layout_update_mutex;
+
+    uint32_t memory_zero;
+    uint32_t math_rand_seed;
+
+    lv_event_t * event_header;
+    uint32_t event_last_register_id;
+
+    lv_timer_state_t timer_state;
+    lv_anim_state_t anim_state;
+    lv_tick_state_t tick_state;
+
+    lv_draw_buf_handlers_t draw_buf_handlers;
+    lv_draw_buf_handlers_t font_draw_buf_handlers;
+    lv_draw_buf_handlers_t image_cache_draw_buf_handlers;  /**< Ensure that all assigned draw buffers
+                                                            * can be managed by image cache. */
+
+    lv_ll_t img_decoder_ll;
+#if LV_USE_OS != LV_OS_NONE
+    lv_mutex_t img_decoder_info_lock;
+    lv_mutex_t img_decoder_open_lock;
+#endif
+
+    lv_cache_t * img_cache;
+    lv_cache_t * img_header_cache;
+
+    lv_draw_global_info_t draw_info;
+    lv_ll_t draw_sw_blend_handler_ll;
+#if defined(LV_DRAW_SW_SHADOW_CACHE_SIZE) && LV_DRAW_SW_SHADOW_CACHE_SIZE > 0
+    lv_draw_sw_shadow_cache_t sw_shadow_cache;
+#endif
+#if LV_DRAW_SW_COMPLEX
+    lv_draw_sw_mask_radius_circle_dsc_arr_t sw_circle_cache;
+#endif
+
+#if LV_USE_LOG
+    lv_log_print_g_cb_t custom_log_print_cb;
+#endif
+
+#if LV_USE_LOG && LV_LOG_USE_TIMESTAMP
+    uint32_t log_last_log_time;
+#endif
+
+#if LV_USE_THEME_SIMPLE
+    void * theme_simple;
+#endif
+
+#if LV_USE_THEME_DEFAULT
+    void * theme_default;
+#endif
+
+#if LV_USE_THEME_MONO
+    void * theme_mono;
+#endif
+
+#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
+    lv_tlsf_state_t tlsf_state;
+#endif
+
+    lv_ll_t fsdrv_ll;
+#if LV_USE_FS_STDIO != '\0'
+    lv_fs_drv_t stdio_fs_drv;
+#endif
+#if LV_USE_FS_POSIX
+    lv_fs_drv_t posix_fs_drv;
+#endif
+
+#if LV_USE_FS_FATFS
+    lv_fs_drv_t fatfs_fs_drv;
+#endif
+
+#if LV_USE_FS_WIN32 != '\0'
+    lv_fs_drv_t win32_fs_drv;
+#endif
+
+#if LV_USE_FS_UEFI
+    lv_fs_drv_t uefi_fs_drv;
+#endif
+
+#if LV_USE_FS_LITTLEFS
+    lv_fs_drv_t littlefs_fs_drv;
+#endif
+
+#if LV_USE_FS_ARDUINO_ESP_LITTLEFS
+    lv_fs_drv_t arduino_esp_littlefs_fs_drv;
+#endif
+
+#if LV_USE_FS_ARDUINO_SD
+    lv_fs_drv_t arduino_sd_fs_drv;
+#endif
+
+#if LV_USE_FS_FROGFS
+    lv_fs_drv_t frogfs_fs_drv;
+#endif
+
+#if LV_USE_FREETYPE
+    struct _lv_freetype_context_t * ft_context;
+#endif
+
+#if LV_USE_FONT_COMPRESSED
+    lv_font_fmt_rle_t font_fmt_rle;
+#endif
+
+#if LV_USE_SPAN != 0
+    struct _snippet_stack * span_snippet_stack;
+#endif
+
+#if LV_USE_PROFILER && LV_USE_PROFILER_BUILTIN
+    struct _lv_profiler_builtin_ctx_t * profiler_context;
+#endif
+
+
+#if LV_USE_FILE_EXPLORER
+    lv_style_t file_explorer_quick_access_style;
+    size_t file_explorer_count;
+#endif
+
+#if LV_USE_MEM_MONITOR
+    lv_sysmon_backend_data_t sysmon_mem;
+#endif
+
+#if LV_USE_IME_PINYIN != 0
+    size_t ime_cand_len;
+#endif
+
+#if LV_USE_OBJ_ID_BUILTIN
+    void * objid_array;
+    uint32_t objid_count;
+#endif
+
+#if LV_USE_TEST
+    lv_test_state_t test_state;
+#endif
+
+#if LV_USE_TRANSLATION
+    lv_ll_t translation_packs_ll;
+    const char * translation_selected_lang;
+#endif
+
+#if LV_USE_NUTTX
+    struct _lv_nuttx_ctx_t * nuttx_ctx;
+#endif
+
+#if LV_USE_OS != LV_OS_NONE
+    lv_mutex_t lv_general_mutex;
+#endif
+
+#if defined(__linux__)
+    lv_linux_proc_stat_t linux_last_proc_stat;
+#if LV_SYSMON_PROC_IDLE_AVAILABLE
+    uint64_t linux_last_self_proc_time_ticks;
+    lv_linux_proc_stat_t linux_last_system_total_ticks_stat;
+#endif
+#endif
+
+#if LV_USE_OS == LV_OS_FREERTOS
+    uint32_t freertos_idle_time_sum;
+    uint32_t freertos_non_idle_time_sum;
+    uint32_t freertos_task_switch_timestamp;
+    bool freertos_idle_task_running;
+#endif
+
+#if LV_USE_EVDEV
+    lv_evdev_discovery_t * evdev_discovery;
+#endif
+
+#if LV_USE_XML
+    const char * xml_path_prefix;
+    uint32_t lv_event_xml_store_timeline;
+    lv_ll_t xml_loads;
+#endif
+
+#if LV_USE_DRAW_EVE
+    lv_draw_eve_unit_t * draw_eve_unit;
+#endif
+} lv_global_t;
+
+/**********************
+ *      MACROS
+ **********************/
+
+#if LV_ENABLE_GLOBAL_CUSTOM
+#include LV_GLOBAL_CUSTOM_INCLUDE
+
+#ifndef LV_GLOBAL_CUSTOM
+#define LV_GLOBAL_CUSTOM() lv_global_default()
+#endif
+#define LV_GLOBAL_DEFAULT() LV_GLOBAL_CUSTOM()
+#else
+LV_ATTRIBUTE_EXTERN_DATA extern lv_global_t lv_global;
+#define LV_GLOBAL_DEFAULT() (&lv_global)
+#endif
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+#if LV_ENABLE_GLOBAL_CUSTOM
+/**
+ * Get the default global object for current thread
+ * @return  pointer to the default global object
+ */
+lv_global_t * lv_global_default(void);
+#endif
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GLOBAL_H*/

components/easylvgl/lvgl9/src/core/lv_group.c

@@ -0,0 +1,530 @@
+/**
+ * @file lv_group.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_group_private.h"
+#include "../core/lv_obj_private.h"
+#include "../core/lv_global.h"
+#include "../indev/lv_indev.h"
+#include "../misc/lv_types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define default_group LV_GLOBAL_DEFAULT()->group_default
+#define group_ll_p &(LV_GLOBAL_DEFAULT()->group_ll)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bool focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
+                            void * (*move)(const lv_ll_t *, const void *));
+static void lv_group_refocus(lv_group_t * g);
+static lv_indev_t * get_indev(const lv_group_t * g);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_group_init(void)
+{
+    lv_ll_init(group_ll_p, sizeof(lv_group_t));
+}
+
+void lv_group_deinit(void)
+{
+    lv_ll_clear(group_ll_p);
+}
+
+lv_group_t * lv_group_create(void)
+{
+    lv_group_t * group = lv_ll_ins_head(group_ll_p);
+    LV_ASSERT_MALLOC(group);
+    if(group == NULL) return NULL;
+    lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));
+
+    group->obj_focus      = NULL;
+    group->frozen         = 0;
+    group->focus_cb       = NULL;
+    group->edge_cb        = NULL;
+    group->editing        = 0;
+    group->refocus_policy = LV_GROUP_REFOCUS_POLICY_PREV;
+    group->wrap           = 1;
+    group->user_data      = NULL;
+
+    return group;
+}
+
+void lv_group_delete(lv_group_t * group)
+{
+    /*Defocus the currently focused object*/
+    LV_ASSERT_NULL(group);
+    if(group->obj_focus != NULL) {
+        lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
+        lv_obj_invalidate(*group->obj_focus);
+    }
+
+    /*Remove the objects from the group*/
+    lv_obj_t ** obj;
+    LV_LL_READ(&group->obj_ll, obj) {
+        if((*obj)->spec_attr)(*obj)->spec_attr->group_p = NULL;
+    }
+
+    /*Remove the group from any indev devices */
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    while(indev) {
+        if(lv_indev_get_group(indev) == group) {
+            lv_indev_set_group(indev, NULL);
+        }
+        indev = lv_indev_get_next(indev);
+    }
+
+    /*If the group is the default group, set the default group as NULL*/
+    if(group == lv_group_get_default()) lv_group_set_default(NULL);
+
+    lv_ll_clear(&(group->obj_ll));
+    lv_ll_remove(group_ll_p, group);
+    lv_free(group);
+}
+
+void lv_group_set_default(lv_group_t * group)
+{
+    default_group = group;
+}
+
+lv_group_t * lv_group_get_default(void)
+{
+    return default_group;
+}
+
+void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
+{
+    if(group == NULL) return;
+
+    LV_LOG_TRACE("begin");
+
+    /*Be sure the object is removed from its current group*/
+    lv_group_remove_obj(obj);
+
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
+    obj->spec_attr->group_p = group;
+
+    lv_obj_t ** next = lv_ll_ins_tail(&group->obj_ll);
+    LV_ASSERT_MALLOC(next);
+    if(next == NULL) return;
+    *next = obj;
+
+    /*If the head and the tail is equal then there is only one object in the linked list.
+     *In this case automatically activate it*/
+    if(lv_ll_get_head(&group->obj_ll) == next) {
+        lv_group_refocus(group);
+    }
+
+    LV_LOG_TRACE("finished");
+}
+
+void lv_group_swap_obj(lv_obj_t * obj1, lv_obj_t * obj2)
+{
+    lv_group_t * g1 = lv_obj_get_group(obj1);
+    lv_group_t * g2 = lv_obj_get_group(obj2);
+    if(g1 != g2) return;
+    if(g1 == NULL) return;
+
+    /*Do not add the object twice*/
+    lv_obj_t ** obj_i;
+    LV_LL_READ(&g1->obj_ll, obj_i) {
+        if((*obj_i) == obj1)(*obj_i) = obj2;
+        else if((*obj_i) == obj2)(*obj_i) = obj1;
+    }
+
+    lv_obj_t * focused = lv_group_get_focused(g1);
+    if(focused == obj1) lv_group_focus_obj(obj2);
+    else if(focused == obj2) lv_group_focus_obj(obj1);
+
+}
+
+void lv_group_remove_obj(lv_obj_t * obj)
+{
+    lv_group_t * g = lv_obj_get_group(obj);
+    if(g == NULL) return;
+
+    LV_LOG_TRACE("begin");
+
+    /*Focus on the next object*/
+    if(g->obj_focus && *g->obj_focus == obj) {
+        if(g->frozen) g->frozen = 0;
+
+        /*If this is the only object in the group then focus to nothing.*/
+        if(lv_ll_get_head(&g->obj_ll) == g->obj_focus && lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
+            lv_obj_send_event(*g->obj_focus, LV_EVENT_DEFOCUSED, get_indev(g));
+        }
+        /*If there more objects in the group then focus to the next/prev object*/
+        else {
+            lv_group_refocus(g);
+        }
+    }
+
+    /*If the focuses object is still the same then it was the only object in the group but it will
+     *be deleted. Set the `obj_focus` to NULL to get back to the initial state of the group with
+     *zero objects*/
+    if(g->obj_focus && *g->obj_focus == obj) {
+        g->obj_focus = NULL;
+    }
+
+    /*Search the object and remove it from its group*/
+    lv_obj_t ** i;
+    LV_LL_READ(&g->obj_ll, i) {
+        if(*i == obj) {
+            lv_ll_remove(&g->obj_ll, i);
+            lv_free(i);
+            if(obj->spec_attr) obj->spec_attr->group_p = NULL;
+            break;
+        }
+    }
+    LV_LOG_TRACE("finished");
+}
+
+void lv_group_remove_all_objs(lv_group_t * group)
+{
+    LV_ASSERT_NULL(group);
+
+    /*Defocus the currently focused object*/
+    if(group->obj_focus != NULL) {
+        lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
+        lv_obj_invalidate(*group->obj_focus);
+        group->obj_focus = NULL;
+    }
+
+    /*Remove the objects from the group*/
+    lv_obj_t ** obj;
+    LV_LL_READ(&group->obj_ll, obj) {
+        if((*obj)->spec_attr)(*obj)->spec_attr->group_p = NULL;
+    }
+
+    lv_ll_clear(&(group->obj_ll));
+}
+
+void lv_group_focus_obj(lv_obj_t * obj)
+{
+    if(obj == NULL) return;
+    lv_group_t * g = lv_obj_get_group(obj);
+    if(g == NULL) return;
+
+    if(g->frozen != 0) return;
+
+    /*On defocus edit mode must be leaved*/
+    lv_group_set_editing(g, false);
+
+    lv_obj_t ** i;
+    LV_LL_READ(&g->obj_ll, i) {
+        if(*i == obj) {
+            if(g->obj_focus != NULL && obj != *g->obj_focus) {  /*Do not defocus if the same object needs to be focused again*/
+                lv_result_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_DEFOCUSED, get_indev(g));
+                if(res != LV_RESULT_OK) return;
+                lv_obj_invalidate(*g->obj_focus);
+            }
+
+            g->obj_focus = i;
+
+            if(g->obj_focus != NULL) {
+                if(g->focus_cb) g->focus_cb(g);
+                lv_result_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_FOCUSED, get_indev(g));
+                if(res != LV_RESULT_OK) return;
+                lv_obj_invalidate(*g->obj_focus);
+            }
+            break;
+        }
+    }
+}
+
+void lv_group_focus_next(lv_group_t * group)
+{
+    LV_ASSERT_NULL(group);
+
+    bool focus_changed = focus_next_core(group, lv_ll_get_head, lv_ll_get_next);
+    if(group->edge_cb) {
+        if(!focus_changed)
+            group->edge_cb(group, true);
+    }
+}
+
+void lv_group_focus_prev(lv_group_t * group)
+{
+    LV_ASSERT_NULL(group);
+
+    bool focus_changed = focus_next_core(group, lv_ll_get_tail, lv_ll_get_prev);
+    if(group->edge_cb) {
+        if(!focus_changed)
+            group->edge_cb(group, false);
+    }
+}
+
+void lv_group_focus_freeze(lv_group_t * group, bool en)
+{
+    LV_ASSERT_NULL(group);
+
+    if(en == false) group->frozen = 0;
+    else group->frozen = 1;
+}
+
+lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c)
+{
+    LV_ASSERT_NULL(group);
+
+    lv_obj_t * act = lv_group_get_focused(group);
+    if(act == NULL) return LV_RESULT_OK;
+
+    if(lv_obj_has_state(act, LV_STATE_DISABLED)) return LV_RESULT_OK;
+
+    return lv_obj_send_event(act, LV_EVENT_KEY, &c);
+}
+
+void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb)
+{
+    if(group == NULL) return;
+
+    group->focus_cb = focus_cb;
+}
+
+void lv_group_set_edge_cb(lv_group_t * group, lv_group_edge_cb_t edge_cb)
+{
+    LV_ASSERT_NULL(group);
+
+    group->edge_cb = edge_cb;
+}
+
+void lv_group_set_editing(lv_group_t * group, bool edit)
+{
+    LV_ASSERT_NULL(group);
+    uint8_t en_val = edit ? 1 : 0;
+
+    if(en_val == group->editing) return; /*Do not set the same mode again*/
+
+    group->editing     = en_val;
+    lv_obj_t * focused = lv_group_get_focused(group);
+
+    if(focused) {
+        lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
+        if(res != LV_RESULT_OK) return;
+
+        lv_obj_invalidate(focused);
+    }
+}
+
+void lv_group_set_refocus_policy(lv_group_t * group, lv_group_refocus_policy_t policy)
+{
+    LV_ASSERT_NULL(group);
+    group->refocus_policy = policy & 0x01;
+}
+
+void lv_group_set_wrap(lv_group_t * group, bool en)
+{
+    LV_ASSERT_NULL(group);
+    group->wrap = en ? 1 : 0;
+}
+
+lv_obj_t * lv_group_get_focused(const lv_group_t * group)
+{
+    if(!group) return NULL;
+    if(group->obj_focus == NULL) return NULL;
+
+    return *group->obj_focus;
+}
+
+lv_group_focus_cb_t lv_group_get_focus_cb(const lv_group_t * group)
+{
+    if(!group) return NULL;
+    return group->focus_cb;
+}
+
+lv_group_edge_cb_t lv_group_get_edge_cb(const lv_group_t * group)
+{
+    if(!group) return NULL;
+    return group->edge_cb;
+}
+
+bool lv_group_get_editing(const lv_group_t * group)
+{
+    if(!group) return false;
+    return group->editing;
+}
+
+bool lv_group_get_wrap(lv_group_t * group)
+{
+    if(!group) return false;
+    return group->wrap;
+}
+
+uint32_t lv_group_get_obj_count(lv_group_t * group)
+{
+    LV_ASSERT_NULL(group);
+    return lv_ll_get_len(&group->obj_ll);
+}
+
+lv_obj_t * lv_group_get_obj_by_index(lv_group_t * group, uint32_t index)
+{
+    uint32_t len = 0;
+    lv_obj_t ** obj;
+
+    LV_LL_READ(&group->obj_ll, obj) {
+        if(len == index) {
+            return *obj;
+        }
+        len++;
+    }
+    return NULL;
+}
+
+uint32_t lv_group_get_count(void)
+{
+    return lv_ll_get_len(group_ll_p);
+}
+
+lv_group_t  * lv_group_by_index(uint32_t index)
+{
+    uint32_t len = 0;
+    lv_group_t * group;
+
+    LV_LL_READ_BACK(group_ll_p, group) {
+        if(len == index) {
+            return group;
+        }
+        len++;
+    }
+
+    return NULL;
+}
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_group_refocus(lv_group_t * g)
+{
+    /*Refocus must temporarily allow wrapping to work correctly*/
+    uint8_t temp_wrap = g->wrap;
+    g->wrap           = 1;
+
+    if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_NEXT)
+        lv_group_focus_next(g);
+    else if(g->refocus_policy == LV_GROUP_REFOCUS_POLICY_PREV)
+        lv_group_focus_prev(g);
+    /*Restore wrap property*/
+    g->wrap = temp_wrap;
+}
+
+static bool focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
+                            void * (*move)(const lv_ll_t *, const void *))
+{
+    bool focus_changed = false;
+    if(group->frozen) return focus_changed;
+
+    lv_obj_t ** obj_next     = group->obj_focus;
+    lv_obj_t ** obj_sentinel = NULL;
+    bool can_move            = true;
+    bool can_begin           = true;
+
+    for(;;) {
+        if(obj_next == NULL) {
+            if(group->wrap || obj_sentinel == NULL) {
+                if(!can_begin) return focus_changed;
+                obj_next  = begin(&group->obj_ll);
+                can_move  = false;
+                can_begin = false;
+            }
+            else {
+                /*Currently focused object is the last/first in the group, keep it that way*/
+                return focus_changed;
+            }
+        }
+
+        if(obj_sentinel == NULL) {
+            obj_sentinel = obj_next;
+            if(obj_sentinel == NULL) return focus_changed; /*Group is empty*/
+        }
+
+        if(can_move) {
+            obj_next = move(&group->obj_ll, obj_next);
+
+            /*Give up if we walked the entire list and haven't found another visible object*/
+            if(obj_next == obj_sentinel) return focus_changed;
+        }
+
+        can_move = true;
+
+        if(obj_next == NULL) continue;
+        if(lv_obj_get_state(*obj_next) & LV_STATE_DISABLED) continue;
+
+        /*Hidden objects don't receive focus.
+         *If any parent is hidden, the object is also hidden)*/
+        lv_obj_t * parent = *obj_next;
+        while(parent) {
+            if(lv_obj_has_flag(parent, LV_OBJ_FLAG_HIDDEN)) break;
+            parent = lv_obj_get_parent(parent);
+        }
+
+        if(parent && lv_obj_has_flag(parent, LV_OBJ_FLAG_HIDDEN)) continue;
+
+        /*If we got her a good candidate is found*/
+        break;
+    }
+
+    if(obj_next == group->obj_focus) return focus_changed; /*There's only one visible object and it's already focused*/
+
+    if(group->obj_focus) {
+        lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
+        if(res != LV_RESULT_OK) return focus_changed;
+        lv_obj_invalidate(*group->obj_focus);
+    }
+
+    group->obj_focus = obj_next;
+
+    lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
+    if(res != LV_RESULT_OK) return focus_changed;
+
+    lv_obj_invalidate(*group->obj_focus);
+
+    if(group->focus_cb) group->focus_cb(group);
+    focus_changed = true;
+    return focus_changed;
+}
+
+/**
+ * Find an indev preferably with POINTER type (because it's the most generic) that uses the given group.
+ * In other words, find an indev, that is related to the given group.
+ * In the worst case simply return the latest indev
+ * @param g     a group the find in the indevs
+ * @return      the suggested indev
+ */
+static lv_indev_t * get_indev(const lv_group_t * g)
+{
+    lv_indev_t * indev_guess = NULL;
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+
+    while(indev) {
+        lv_indev_type_t indev_type = lv_indev_get_type(indev);
+        /*Prefer POINTER*/
+        if(indev_type == LV_INDEV_TYPE_POINTER) return indev;
+        if(lv_indev_get_group(indev) == g) {
+            indev_guess = indev;
+        }
+        indev = lv_indev_get_next(indev);
+    }
+
+    return indev_guess;
+}

components/easylvgl/lvgl9/src/core/lv_group.h

@@ -0,0 +1,248 @@
+/**
+ * @file lv_group.h
+ *
+ */
+
+#ifndef LV_GROUP_H
+#define LV_GROUP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#include "../misc/lv_types.h"
+#include "../misc/lv_ll.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+/** Predefined keys to control which Widget has focus via lv_group_send(group, c) */
+typedef enum {
+    LV_KEY_UP        = 17,  /*0x11*/
+    LV_KEY_DOWN      = 18,  /*0x12*/
+    LV_KEY_RIGHT     = 19,  /*0x13*/
+    LV_KEY_LEFT      = 20,  /*0x14*/
+    LV_KEY_ESC       = 27,  /*0x1B*/
+    LV_KEY_DEL       = 127, /*0x7F*/
+    LV_KEY_BACKSPACE = 8,   /*0x08*/
+    LV_KEY_ENTER     = 10,  /*0x0A, '\n'*/
+    LV_KEY_NEXT      = 9,   /*0x09, '\t'*/
+    LV_KEY_PREV      = 11,  /*0x0B, '*/
+    LV_KEY_HOME      = 2,   /*0x02, STX*/
+    LV_KEY_END       = 3,   /*0x03, ETX*/
+} lv_key_t;
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef void (*lv_group_focus_cb_t)(lv_group_t *);
+typedef void (*lv_group_edge_cb_t)(lv_group_t *, bool);
+
+typedef enum {
+    LV_GROUP_REFOCUS_POLICY_NEXT = 0,
+    LV_GROUP_REFOCUS_POLICY_PREV = 1
+} lv_group_refocus_policy_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create new Widget group.
+ * @return          pointer to the new Widget group
+ */
+lv_group_t * lv_group_create(void);
+
+/**
+ * Delete group object.
+ * @param group     pointer to a group
+ */
+void lv_group_delete(lv_group_t * group);
+
+/**
+ * Set default group. New Widgets will be added to this group if it's enabled in
+ * their class with `add_to_def_group = true`.
+ * @param group     pointer to a group (can be `NULL`)
+ */
+void lv_group_set_default(lv_group_t * group);
+
+/**
+ * Get default group.
+ * @return          pointer to the default group
+ */
+lv_group_t * lv_group_get_default(void);
+
+/**
+ * Add an Widget to group.
+ * @param group     pointer to a group
+ * @param obj       pointer to a Widget to add
+ */
+void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj);
+
+/**
+ * Swap 2 Widgets in group.  Widgets must be in the same group.
+ * @param obj1  pointer to a Widget
+ * @param obj2  pointer to another Widget
+ */
+void lv_group_swap_obj(lv_obj_t * obj1, lv_obj_t * obj2);
+
+/**
+ * Remove a Widget from its group.
+ * @param obj       pointer to Widget to remove
+ */
+void lv_group_remove_obj(lv_obj_t * obj);
+
+/**
+ * Remove all Widgets from a group.
+ * @param group     pointer to a group
+ */
+void lv_group_remove_all_objs(lv_group_t * group);
+
+/**
+ * Focus on a Widget (defocus the current).
+ * @param obj       pointer to Widget to focus on
+ */
+void lv_group_focus_obj(lv_obj_t * obj);
+
+/**
+ * Focus on next Widget in a group (defocus the current).
+ * @param group     pointer to a group
+ */
+void lv_group_focus_next(lv_group_t * group);
+
+/**
+ * Focus on previous Widget in a group (defocus the current).
+ * @param group     pointer to a group
+ */
+void lv_group_focus_prev(lv_group_t * group);
+
+/**
+ * Do not allow changing focus from current Widget.
+ * @param group     pointer to a group
+ * @param en        true: freeze, false: release freezing (normal mode)
+ */
+void lv_group_focus_freeze(lv_group_t * group, bool en);
+
+/**
+ * Send a control character to Widget that has focus in a group.
+ * @param group     pointer to a group
+ * @param c         a character (use LV_KEY_.. to navigate)
+ * @return          result of Widget with focus in group.
+ */
+lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c);
+
+/**
+ * Set a function for a group which will be called when a new Widget has focus.
+ * @param group         pointer to a group
+ * @param focus_cb      the call back function or NULL if unused
+ */
+void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb);
+
+/**
+ * Set a function for a group which will be called when a focus edge is reached
+ * @param group         pointer to a group
+ * @param edge_cb      the call back function or NULL if unused
+ */
+void lv_group_set_edge_cb(lv_group_t * group, lv_group_edge_cb_t edge_cb);
+
+/**
+ * Set whether the next or previous Widget in a group gets focus when Widget that has
+ * focus is deleted.
+ * @param group         pointer to a group
+ * @param policy        new refocus policy enum
+ */
+void lv_group_set_refocus_policy(lv_group_t * group, lv_group_refocus_policy_t policy);
+
+/**
+ * Manually set the current mode (edit or navigate).
+ * @param group         pointer to group
+ * @param edit          true: edit mode; false: navigate mode
+ */
+void lv_group_set_editing(lv_group_t * group, bool edit);
+
+/**
+ * Set whether moving focus to next/previous Widget will allow wrapping from
+ * first->last or last->first Widget.
+ * @param group         pointer to group
+ * @param               en true: wrapping enabled; false: wrapping disabled
+ */
+void lv_group_set_wrap(lv_group_t * group, bool en);
+
+/**
+ * Get Widget that has focus, or NULL if there isn't one.
+ * @param group         pointer to a group
+ * @return              pointer to Widget with focus
+ */
+lv_obj_t * lv_group_get_focused(const lv_group_t * group);
+
+/**
+ * Get focus callback function of a group.
+ * @param group pointer to a group
+ * @return the call back function or NULL if not set
+ */
+lv_group_focus_cb_t lv_group_get_focus_cb(const lv_group_t * group);
+
+/**
+ * Get edge callback function of a group.
+ * @param group pointer to a group
+ * @return the call back function or NULL if not set
+ */
+lv_group_edge_cb_t lv_group_get_edge_cb(const lv_group_t * group);
+
+/**
+ * Get current mode (edit or navigate).
+ * @param group         pointer to group
+ * @return              true: edit mode; false: navigate mode
+ */
+bool lv_group_get_editing(const lv_group_t * group);
+
+/**
+ * Get whether moving focus to next/previous Widget will allow wrapping from
+ * first->last or last->first Widget.
+ * @param group         pointer to group
+ */
+bool lv_group_get_wrap(lv_group_t * group);
+
+/**
+ * Get number of Widgets in group.
+ * @param group         pointer to a group
+ * @return              number of Widgets in the group
+ */
+uint32_t lv_group_get_obj_count(lv_group_t * group);
+
+/**
+ * Get nth Widget within group.
+ * @param group         pointer to a group
+ * @param index         index of Widget within the group
+ * @return              pointer to Widget
+ */
+lv_obj_t * lv_group_get_obj_by_index(lv_group_t * group, uint32_t index);
+
+/**
+ * Get the number of groups.
+ * @return              number of groups
+ */
+uint32_t lv_group_get_count(void);
+
+/**
+ * Get a group by its index.
+ * @param index         index of the group
+ * @return              pointer to the group
+ */
+lv_group_t  * lv_group_by_index(uint32_t index);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GROUP_H*/

components/easylvgl/lvgl9/src/core/lv_group_private.h

@@ -0,0 +1,75 @@
+/**
+ * @file lv_group_private.h
+ *
+ */
+
+#ifndef LV_GROUP_PRIVATE_H
+#define LV_GROUP_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_group.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Groups can be used to logically hold objects so that they can be individually focused.
+ * They are NOT for laying out objects on a screen (try layouts for that).
+ */
+struct _lv_group_t {
+    lv_ll_t obj_ll;        /**< Linked list to store the objects in the group*/
+    lv_obj_t ** obj_focus; /**< The object in focus*/
+
+    lv_group_focus_cb_t focus_cb;              /**< A function to call when a new object is focused (optional)*/
+    lv_group_edge_cb_t  edge_cb;               /**< A function to call when an edge is reached, no more focus
+                                                    targets are available in this direction (to allow edge feedback
+                                                    like a sound or a scroll bounce) */
+
+    void * user_data;
+
+    uint8_t frozen : 1;         /**< 1: can't focus to new object*/
+    uint8_t editing : 1;        /**< 1: Edit mode, 0: Navigate mode*/
+    uint8_t refocus_policy : 1; /**< 1: Focus prev if focused on deletion. 0: Focus next if focused on
+                                   deletion.*/
+    uint8_t wrap : 1;           /**< 1: Focus next/prev can wrap at end of list. 0: Focus next/prev stops at end
+                                   of list.*/
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Init the group module
+ * @remarks Internal function, do not call directly.
+ */
+void lv_group_init(void);
+
+/**
+ * Deinit the group module
+ * @remarks Internal function, do not call directly.
+ */
+void lv_group_deinit(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GROUP_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj.c

@@ -0,0 +1,1229 @@
+/**
+ * @file lv_obj.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_private.h"
+#include "../misc/lv_event_private.h"
+#include "../misc/lv_area_private.h"
+#include "lv_obj_style_private.h"
+#include "lv_obj_event_private.h"
+#include "lv_obj_class_private.h"
+#include "../indev/lv_indev.h"
+#include "../indev/lv_indev_private.h"
+#include "lv_refr.h"
+#include "lv_group.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "../themes/lv_theme.h"
+#include "../misc/lv_assert.h"
+#include "../misc/lv_math.h"
+#include "../misc/lv_log.h"
+#include "../misc/lv_types.h"
+#include "../misc/lv_anim_timeline.h"
+#include "../tick/lv_tick.h"
+#include "../stdlib/lv_string.h"
+#include "lv_obj_draw_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+#define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
+#define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
+#define STYLE_TRANSITION_MAX 32
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_screen_load_anim_t anim_type;
+    uint32_t duration;
+    uint32_t delay;
+    union {
+        lv_obj_t * screen;
+        lv_screen_create_cb_t create_cb;
+    } target;
+} screen_load_anim_dsc_t;
+
+typedef struct {
+    lv_anim_timeline_t * at;
+    uint32_t delay;
+    bool reverse;
+} timeline_play_dsc_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_obj_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
+static void lv_obj_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
+static void lv_obj_draw(lv_event_t * e);
+static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e);
+static void draw_scrollbar(lv_obj_t * obj, lv_layer_t * layer);
+static lv_result_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
+static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
+static void update_obj_state(lv_obj_t * obj, lv_state_t new_state);
+static void lv_obj_children_add_state(lv_obj_t * obj, lv_state_t state);
+static void lv_obj_children_remove_state(lv_obj_t * obj, lv_state_t state);
+static void null_on_delete_cb(lv_event_t * e);
+static void screen_load_on_trigger_event_cb(lv_event_t * e);
+static void screen_create_on_trigger_event_cb(lv_event_t * e);
+static void play_timeline_on_trigger_event_cb(lv_event_t * e);
+static void delete_on_screen_unloaded_event_cb(lv_event_t * e);
+
+#if LV_USE_OBJ_PROPERTY
+    static lv_result_t lv_obj_set_any(lv_obj_t *, lv_prop_id_t, const lv_property_t *);
+    static lv_result_t lv_obj_get_any(const lv_obj_t *, lv_prop_id_t, lv_property_t *);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+#if LV_USE_OBJ_PROPERTY
+static const lv_property_ops_t properties[] = {
+    {
+        .id = LV_PROPERTY_OBJ_PARENT,
+        .setter = lv_obj_set_parent,
+        .getter = lv_obj_get_parent,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_X,
+        .setter = lv_obj_set_x,
+        .getter = lv_obj_get_x,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_Y,
+        .setter = lv_obj_set_y,
+        .getter = lv_obj_get_y,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_W,
+        .setter = lv_obj_set_width,
+        .getter = lv_obj_get_width,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_H,
+        .setter = lv_obj_set_height,
+        .getter = lv_obj_get_height,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_CONTENT_WIDTH,
+        .setter = lv_obj_set_content_width,
+        .getter = lv_obj_get_content_width,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_CONTENT_HEIGHT,
+        .setter = lv_obj_set_content_height,
+        .getter = lv_obj_get_content_height,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_LAYOUT,
+        .setter = lv_obj_set_layout,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_ALIGN,
+        .setter = lv_obj_set_align,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLLBAR_MODE,
+        .setter = lv_obj_set_scrollbar_mode,
+        .getter = lv_obj_get_scrollbar_mode,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_DIR,
+        .setter = lv_obj_set_scroll_dir,
+        .getter = lv_obj_get_scroll_dir,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_SNAP_X,
+        .setter = lv_obj_set_scroll_snap_x,
+        .getter = lv_obj_get_scroll_snap_x,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_SNAP_Y,
+        .setter = lv_obj_set_scroll_snap_y,
+        .getter = lv_obj_get_scroll_snap_y,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_TOP,
+        .getter = lv_obj_get_scroll_top,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_BOTTOM,
+        .getter = lv_obj_get_scroll_bottom,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_LEFT,
+        .getter = lv_obj_get_scroll_left,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_RIGHT,
+        .getter = lv_obj_get_scroll_right,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCROLL_END,
+        .getter = lv_obj_get_scroll_end,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_EXT_DRAW_SIZE,
+        .getter = lv_obj_get_ext_draw_size,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_EVENT_COUNT,
+        .getter = lv_obj_get_event_count,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_SCREEN,
+        .getter = lv_obj_get_screen,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_DISPLAY,
+        .getter = lv_obj_get_display,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_CHILD_COUNT,
+        .getter = lv_obj_get_child_count,
+    },
+    {
+        .id = LV_PROPERTY_OBJ_INDEX,
+        .getter = lv_obj_get_index,
+    },
+    {
+        .id = LV_PROPERTY_ID_ANY,
+        .setter = lv_obj_set_any,
+        .getter = lv_obj_get_any,
+    }
+};
+#endif
+
+const lv_obj_class_t lv_obj_class = {
+    .constructor_cb = lv_obj_constructor,
+    .destructor_cb = lv_obj_destructor,
+    .event_cb = lv_obj_event,
+    .width_def = LV_DPI_DEF,
+    .height_def = LV_DPI_DEF,
+    .editable = LV_OBJ_CLASS_EDITABLE_FALSE,
+    .group_def = LV_OBJ_CLASS_GROUP_DEF_FALSE,
+    .instance_size = (sizeof(lv_obj_t)),
+    .base_class = NULL,
+    .name = "lv_obj",
+#if LV_USE_OBJ_PROPERTY
+    .prop_index_start = LV_PROPERTY_OBJ_START,
+    .prop_index_end = LV_PROPERTY_OBJ_END,
+    .properties = properties,
+    .properties_count = sizeof(properties) / sizeof(properties[0]),
+
+#if LV_USE_OBJ_PROPERTY_NAME
+    .property_names = lv_obj_property_names,
+    .names_count = sizeof(lv_obj_property_names) / sizeof(lv_property_name_t),
+#endif
+
+#endif
+};
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_obj_t * lv_obj_create(lv_obj_t * parent)
+{
+    LV_LOG_INFO("begin");
+    lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
+    LV_ASSERT_NULL(obj);
+    if(obj == NULL) return NULL;
+    lv_obj_class_init_obj(obj);
+    return obj;
+}
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*-----------------
+ * Attribute set
+ *----------------*/
+
+void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(lv_obj_has_flag(obj, f)) /*Check if all flags are set*/
+        return;
+
+    bool was_on_layout = lv_obj_is_layout_positioned(obj);
+
+    /* We must invalidate the area occupied by the object before we hide it as calls to invalidate hidden objects are ignored */
+    if(f & LV_OBJ_FLAG_HIDDEN) lv_obj_invalidate(obj);
+
+    obj->flags |= f;
+
+    if(f & LV_OBJ_FLAG_HIDDEN) {
+        if(lv_obj_has_state(obj, LV_STATE_FOCUSED)) {
+            lv_group_t * group = lv_obj_get_group(obj);
+            if(group != NULL) {
+                lv_group_focus_next(group);
+                lv_obj_t * next_obj = lv_group_get_focused(group);
+                if(next_obj != NULL) {
+                    lv_obj_invalidate(next_obj);
+                }
+            }
+        }
+    }
+
+    if((was_on_layout != lv_obj_is_layout_positioned(obj)) || (f & (LV_OBJ_FLAG_LAYOUT_1 |  LV_OBJ_FLAG_LAYOUT_2))) {
+        lv_obj_mark_layout_as_dirty(lv_obj_get_parent(obj));
+        lv_obj_mark_layout_as_dirty(obj);
+    }
+
+    if(f & LV_OBJ_FLAG_SCROLLABLE) {
+        lv_area_t hor_area, ver_area;
+        lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+        lv_obj_invalidate_area(obj, &hor_area);
+        lv_obj_invalidate_area(obj, &ver_area);
+    }
+}
+
+void lv_obj_remove_flag(lv_obj_t * obj, lv_obj_flag_t f)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(!lv_obj_has_flag_any(obj, f))
+        return;
+
+    bool was_on_layout = lv_obj_is_layout_positioned(obj);
+    if(f & LV_OBJ_FLAG_SCROLLABLE) {
+        lv_area_t hor_area, ver_area;
+        lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+        lv_obj_invalidate_area(obj, &hor_area);
+        lv_obj_invalidate_area(obj, &ver_area);
+    }
+
+    obj->flags &= (~f);
+
+    if(f & LV_OBJ_FLAG_HIDDEN) {
+        lv_obj_invalidate(obj);
+        lv_obj_mark_layout_as_dirty(lv_obj_get_parent(obj));
+        lv_obj_mark_layout_as_dirty(obj);
+    }
+
+    if((was_on_layout != lv_obj_is_layout_positioned(obj)) || (f & (LV_OBJ_FLAG_LAYOUT_1 |  LV_OBJ_FLAG_LAYOUT_2))) {
+        lv_obj_mark_layout_as_dirty(lv_obj_get_parent(obj));
+    }
+
+}
+
+void lv_obj_set_flag(lv_obj_t * obj, lv_obj_flag_t f, bool v)
+{
+    if(v) lv_obj_add_flag(obj, f);
+    else lv_obj_remove_flag(obj, f);
+}
+
+void lv_obj_add_state(lv_obj_t * obj, lv_state_t state)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_state_t new_state = obj->state | state;
+    if(obj->state != new_state) {
+        update_obj_state(obj, new_state);
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_STATE_TRICKLE)) {
+            lv_obj_children_add_state(obj, state);
+        }
+    }
+}
+
+void lv_obj_remove_state(lv_obj_t * obj, lv_state_t state)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_state_t new_state = obj->state & (~state);
+    if(obj->state != new_state) {
+        update_obj_state(obj, new_state);
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_STATE_TRICKLE)) {
+            lv_obj_children_remove_state(obj, state);
+        }
+    }
+}
+
+void lv_obj_set_state(lv_obj_t * obj, lv_state_t state, bool v)
+{
+    if(v) lv_obj_add_state(obj, state);
+    else lv_obj_remove_state(obj, state);
+}
+
+/*=======================
+ * Getter functions
+ *======================*/
+
+bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return (obj->flags & f)  == f;
+}
+
+bool lv_obj_has_flag_any(const lv_obj_t * obj, lv_obj_flag_t f)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return !!(obj->flags & f);
+}
+
+lv_state_t lv_obj_get_state(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return obj->state;
+}
+
+bool lv_obj_has_state(const lv_obj_t * obj, lv_state_t state)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return !!(obj->state & state);
+}
+
+lv_group_t * lv_obj_get_group(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr) return obj->spec_attr->group_p;
+    else return NULL;
+}
+
+/*-------------------
+ * OTHER FUNCTIONS
+ *------------------*/
+
+void lv_obj_allocate_spec_attr(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr == NULL) {
+        obj->spec_attr = lv_malloc_zeroed(sizeof(lv_obj_spec_attr_t));
+        LV_ASSERT_MALLOC(obj->spec_attr);
+        if(obj->spec_attr == NULL) return;
+
+        obj->spec_attr->scroll_dir = LV_DIR_ALL;
+        obj->spec_attr->scrollbar_mode = LV_SCROLLBAR_MODE_AUTO;
+    }
+}
+
+bool lv_obj_check_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
+{
+    if(obj == NULL) return false;
+    return obj->class_p == class_p;
+}
+
+bool lv_obj_has_class(const lv_obj_t * obj, const lv_obj_class_t * class_p)
+{
+    const lv_obj_class_t * obj_class = obj->class_p;
+    while(obj_class) {
+        if(obj_class == class_p) return true;
+        obj_class = obj_class->base_class;
+    }
+
+    return false;
+}
+
+const lv_obj_class_t * lv_obj_get_class(const lv_obj_t * obj)
+{
+    return obj->class_p;
+}
+
+bool lv_obj_is_valid(const lv_obj_t * obj)
+{
+    lv_display_t * disp = lv_display_get_next(NULL);
+    while(disp) {
+        uint32_t i;
+        for(i = 0; i < disp->screen_cnt; i++) {
+            if(disp->screens[i] == obj) return true;
+            bool found = obj_valid_child(disp->screens[i], obj);
+            if(found) return true;
+        }
+
+        disp = lv_display_get_next(disp);
+    }
+
+    return false;
+}
+
+void lv_obj_null_on_delete(lv_obj_t ** obj_ptr)
+{
+    lv_obj_add_event_cb(*obj_ptr, null_on_delete_cb, LV_EVENT_DELETE, obj_ptr);
+}
+
+#if LV_USE_OBJ_ID
+void * lv_obj_get_id(const lv_obj_t * obj)
+{
+    LV_ASSERT_NULL(obj);
+    return obj->id;
+}
+
+lv_obj_t * lv_obj_find_by_id(const lv_obj_t * obj, const void * id)
+{
+    LV_LOG_WARN("DEPRECATED: IDs are used only to print the widget trees. To find a widget use obj_name");
+
+    if(obj == NULL) obj = lv_display_get_screen_active(NULL);
+    if(obj == NULL) return NULL;
+
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_id_compare(child->id, id) == 0) return child;
+    }
+
+    /*Search children*/
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        lv_obj_t * found = lv_obj_find_by_id(child, id);
+        if(found != NULL) return found;
+    }
+
+    return NULL;
+}
+#endif
+
+void lv_obj_add_screen_load_event(lv_obj_t * obj, lv_event_code_t trigger, lv_obj_t * screen,
+                                  lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay)
+{
+    if(screen == NULL) {
+        LV_LOG_WARN("`screen` is NULL, can't load a non existing screens");
+        return;
+    }
+
+    screen_load_anim_dsc_t * dsc = lv_malloc(sizeof(screen_load_anim_dsc_t));
+    LV_ASSERT_MALLOC(dsc);
+    lv_memzero(dsc, sizeof(screen_load_anim_dsc_t));
+    dsc->anim_type = anim_type;
+    dsc->duration = duration;
+    dsc->delay = delay;
+    dsc->target.screen = screen;
+
+    lv_obj_add_event_cb(obj, screen_load_on_trigger_event_cb, trigger, dsc);
+    lv_obj_add_event_cb(obj, lv_event_free_user_data_cb, LV_EVENT_DELETE, dsc);
+}
+
+void lv_obj_add_screen_create_event(lv_obj_t * obj, lv_event_code_t trigger, lv_screen_create_cb_t screen_create_cb,
+                                    lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay)
+{
+    screen_load_anim_dsc_t * dsc = lv_malloc(sizeof(screen_load_anim_dsc_t));
+    LV_ASSERT_MALLOC(dsc);
+    lv_memzero(dsc, sizeof(screen_load_anim_dsc_t));
+    dsc->anim_type = anim_type;
+    dsc->duration = duration;
+    dsc->delay = delay;
+    dsc->target.create_cb = screen_create_cb;
+
+    lv_obj_add_event_cb(obj, screen_create_on_trigger_event_cb, trigger, dsc);
+    lv_obj_add_event_cb(obj, lv_event_free_user_data_cb, LV_EVENT_DELETE, dsc);
+}
+
+void lv_obj_add_play_timeline_event(lv_obj_t * obj, lv_event_code_t trigger, lv_anim_timeline_t * at, uint32_t delay,
+                                    bool reverse)
+{
+    timeline_play_dsc_t * dsc = lv_malloc(sizeof(timeline_play_dsc_t));
+    LV_ASSERT_MALLOC(dsc);
+    lv_memzero(dsc, sizeof(timeline_play_dsc_t));
+    dsc->at = at;
+    dsc->delay = delay;
+    dsc->reverse = reverse;
+
+    lv_obj_add_event_cb(obj, play_timeline_on_trigger_event_cb, trigger, dsc);
+    lv_obj_add_event_cb(obj, lv_event_free_user_data_cb, LV_EVENT_DELETE, dsc);
+}
+
+void lv_obj_set_user_data(lv_obj_t * obj, void * user_data)
+{
+    obj->user_data = user_data;
+}
+
+void * lv_obj_get_user_data(lv_obj_t * obj)
+{
+    return obj->user_data;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_obj_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
+{
+    LV_UNUSED(class_p);
+    LV_TRACE_OBJ_CREATE("begin");
+
+    lv_obj_t * parent = obj->parent;
+    if(parent) {
+        int32_t sl = lv_obj_get_scroll_left(parent);
+        int32_t st = lv_obj_get_scroll_top(parent);
+
+        obj->coords.y1 = parent->coords.y1 + lv_obj_get_style_pad_top(parent, LV_PART_MAIN) - st;
+        obj->coords.y2 = obj->coords.y1 - 1;
+        obj->coords.x1  = parent->coords.x1 + lv_obj_get_style_pad_left(parent, LV_PART_MAIN) - sl;
+        obj->coords.x2  = obj->coords.x1 - 1;
+    }
+
+    /*Set attributes*/
+    obj->flags = LV_OBJ_FLAG_CLICKABLE;
+    obj->flags |= LV_OBJ_FLAG_SNAPPABLE;
+    if(parent) obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
+    if(parent) obj->flags |= LV_OBJ_FLAG_SCROLL_CHAIN;
+    obj->flags |= LV_OBJ_FLAG_CLICK_FOCUSABLE;
+    obj->flags |= LV_OBJ_FLAG_SCROLLABLE;
+    obj->flags |= LV_OBJ_FLAG_SCROLL_ELASTIC;
+    obj->flags |= LV_OBJ_FLAG_SCROLL_MOMENTUM;
+    obj->flags |= LV_OBJ_FLAG_SCROLL_WITH_ARROW;
+    if(parent) obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
+
+#if LV_OBJ_ID_AUTO_ASSIGN
+    lv_obj_assign_id(class_p, obj);
+#endif
+
+    LV_TRACE_OBJ_CREATE("finished");
+}
+
+static void lv_obj_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
+{
+    LV_UNUSED(class_p);
+
+    lv_event_mark_deleted(obj);
+
+    /*Remove all style*/
+    lv_obj_enable_style_refresh(false); /*No need to refresh the style because the object will be deleted*/
+    lv_obj_remove_style_all(obj);
+    lv_obj_enable_style_refresh(true);
+
+    /*Remove the animations from this object*/
+    lv_anim_delete(obj, NULL);
+
+    /*Delete from the group*/
+    lv_group_t * group = lv_obj_get_group(obj);
+    if(group) lv_group_remove_obj(obj);
+
+    if(obj->spec_attr) {
+        if(obj->spec_attr->children) {
+            lv_free(obj->spec_attr->children);
+            obj->spec_attr->children = NULL;
+        }
+
+        lv_event_remove_all(&obj->spec_attr->event_list);
+#if LV_USE_OBJ_NAME
+        if(obj->spec_attr->name && !obj->spec_attr->name_static) {
+            lv_free((void *)obj->spec_attr->name);
+        }
+#endif
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+        if(obj->spec_attr->matrix) {
+            lv_free(obj->spec_attr->matrix);
+            obj->spec_attr->matrix = NULL;
+        }
+#endif
+
+        lv_free(obj->spec_attr);
+        obj->spec_attr = NULL;
+    }
+
+#if LV_OBJ_ID_AUTO_ASSIGN
+    lv_obj_free_id(obj);
+#endif
+}
+
+static void lv_obj_draw(lv_event_t * e)
+{
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * obj = lv_event_get_current_target(e);
+    if(code == LV_EVENT_COVER_CHECK) {
+        lv_cover_check_info_t * info = lv_event_get_param(e);
+        if(info->res == LV_COVER_RES_MASKED) return;
+        if(lv_obj_get_style_clip_corner(obj, LV_PART_MAIN)) {
+            info->res = LV_COVER_RES_MASKED;
+            return;
+        }
+
+        /*Most trivial test. Is the mask fully IN the object? If no it surely doesn't cover it*/
+        int32_t r = lv_obj_get_style_radius(obj, LV_PART_MAIN);
+        int32_t w = lv_obj_get_style_transform_width(obj, LV_PART_MAIN);
+        int32_t h = lv_obj_get_style_transform_height(obj, LV_PART_MAIN);
+        lv_area_t coords;
+        lv_area_copy(&coords, &obj->coords);
+        lv_area_increase(&coords, w, h);
+
+        if(lv_area_is_in(info->area, &coords, r) == false) {
+            info->res = LV_COVER_RES_NOT_COVER;
+            return;
+        }
+
+        if(lv_obj_get_style_bg_opa(obj, LV_PART_MAIN) < LV_OPA_MAX) {
+            info->res = LV_COVER_RES_NOT_COVER;
+            return;
+        }
+
+        if(lv_obj_get_style_opa(obj, LV_PART_MAIN) < LV_OPA_MAX) {
+            info->res = LV_COVER_RES_NOT_COVER;
+            return;
+        }
+
+        if(lv_obj_get_style_bg_grad_dir(obj, LV_PART_MAIN) != LV_GRAD_DIR_NONE) {
+            if(lv_obj_get_style_bg_grad_opa(obj, LV_PART_MAIN) < LV_OPA_MAX ||
+               lv_obj_get_style_bg_main_opa(obj, LV_PART_MAIN) < LV_OPA_MAX) {
+                info->res = LV_COVER_RES_NOT_COVER;
+                return;
+            }
+        }
+        const lv_grad_dsc_t * grad_dsc = lv_obj_get_style_bg_grad(obj, LV_PART_MAIN);
+        if(grad_dsc) {
+            uint32_t i;
+            for(i = 0; i < grad_dsc->stops_count; i++) {
+                if(grad_dsc->stops[i].opa < LV_OPA_MAX) {
+                    info->res = LV_COVER_RES_NOT_COVER;
+                    return;
+                }
+            }
+        }
+        info->res = LV_COVER_RES_COVER;
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
+        lv_layer_t * layer = lv_event_get_layer(e);
+        lv_draw_rect_dsc_t draw_dsc;
+        lv_draw_rect_dsc_init(&draw_dsc);
+        draw_dsc.base.layer = layer;
+
+        lv_obj_init_draw_rect_dsc(obj, LV_PART_MAIN, &draw_dsc);
+        /*If the border is drawn later disable loading its properties*/
+        if(lv_obj_get_style_border_post(obj, LV_PART_MAIN)) {
+            draw_dsc.border_post = 1;
+        }
+
+        int32_t w = lv_obj_get_style_transform_width(obj, LV_PART_MAIN);
+        int32_t h = lv_obj_get_style_transform_height(obj, LV_PART_MAIN);
+        lv_area_t coords;
+        lv_area_copy(&coords, &obj->coords);
+        lv_area_increase(&coords, w, h);
+
+        lv_draw_rect(layer, &draw_dsc, &coords);
+    }
+    else if(code == LV_EVENT_DRAW_POST) {
+        lv_layer_t * layer = lv_event_get_layer(e);
+        draw_scrollbar(obj, layer);
+
+        /*If the border is drawn later disable loading other properties*/
+        if(lv_obj_get_style_border_width(obj, LV_PART_MAIN) &&
+           lv_obj_get_style_border_post(obj, LV_PART_MAIN)) {
+            lv_draw_rect_dsc_t draw_dsc;
+            lv_draw_rect_dsc_init(&draw_dsc);
+            draw_dsc.bg_opa = LV_OPA_TRANSP;
+            draw_dsc.bg_image_opa = LV_OPA_TRANSP;
+            draw_dsc.outline_opa = LV_OPA_TRANSP;
+            draw_dsc.shadow_opa = LV_OPA_TRANSP;
+            draw_dsc.base.layer = layer;
+            lv_obj_init_draw_rect_dsc(obj, LV_PART_MAIN, &draw_dsc);
+
+            int32_t w = lv_obj_get_style_transform_width(obj, LV_PART_MAIN);
+            int32_t h = lv_obj_get_style_transform_height(obj, LV_PART_MAIN);
+            lv_area_t coords;
+            lv_area_copy(&coords, &obj->coords);
+            lv_area_increase(&coords, w, h);
+
+            lv_draw_rect(layer, &draw_dsc, &coords);
+        }
+    }
+}
+
+static void draw_scrollbar(lv_obj_t * obj, lv_layer_t * layer)
+{
+
+    lv_area_t hor_area;
+    lv_area_t ver_area;
+    lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+
+    if(lv_area_get_size(&hor_area) <= 0 && lv_area_get_size(&ver_area) <= 0) return;
+
+    lv_draw_rect_dsc_t draw_dsc;
+    lv_result_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
+    if(sb_res != LV_RESULT_OK) return;
+
+    if(lv_area_get_size(&hor_area) > 0) {
+        draw_dsc.base.id1 = 0;
+        lv_draw_rect(layer, &draw_dsc, &hor_area);
+    }
+    if(lv_area_get_size(&ver_area) > 0) {
+        draw_dsc.base.id1 = 1;
+        lv_draw_rect(layer, &draw_dsc, &ver_area);
+    }
+}
+
+/**
+ * Initialize the draw descriptor for the scrollbar
+ * @param obj pointer to an object
+ * @param dsc the draw descriptor to initialize
+ * @return LV_RESULT_OK: the scrollbar is visible; LV_RESULT_INVALID: the scrollbar is not visible
+ */
+static lv_result_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
+{
+    lv_draw_rect_dsc_init(dsc);
+    dsc->bg_opa = lv_obj_get_style_bg_opa(obj, LV_PART_SCROLLBAR);
+    if(dsc->bg_opa > LV_OPA_MIN) {
+        dsc->bg_color = lv_obj_get_style_bg_color(obj, LV_PART_SCROLLBAR);
+    }
+
+    dsc->border_opa = lv_obj_get_style_border_opa(obj, LV_PART_SCROLLBAR);
+    if(dsc->border_opa > LV_OPA_MIN) {
+        dsc->border_width = lv_obj_get_style_border_width(obj, LV_PART_SCROLLBAR);
+        if(dsc->border_width > 0) {
+            dsc->border_color = lv_obj_get_style_border_color(obj, LV_PART_SCROLLBAR);
+        }
+        else {
+            dsc->border_opa = LV_OPA_TRANSP;
+        }
+    }
+
+    dsc->shadow_opa = lv_obj_get_style_shadow_opa(obj, LV_PART_SCROLLBAR);
+    if(dsc->shadow_opa > LV_OPA_MIN) {
+        dsc->shadow_width = lv_obj_get_style_shadow_width(obj, LV_PART_SCROLLBAR);
+        if(dsc->shadow_width > 0) {
+            dsc->shadow_spread = lv_obj_get_style_shadow_spread(obj, LV_PART_SCROLLBAR);
+            dsc->shadow_color = lv_obj_get_style_shadow_color(obj, LV_PART_SCROLLBAR);
+        }
+        else {
+            dsc->shadow_opa = LV_OPA_TRANSP;
+        }
+    }
+
+    lv_opa_t opa = lv_obj_get_style_opa_recursive(obj, LV_PART_SCROLLBAR);
+    if(opa < LV_OPA_MAX) {
+        lv_opa_t v = LV_OPA_MIX2(dsc->bg_opa, opa);
+        dsc->bg_opa = v;
+        dsc->border_opa = v;
+        dsc->shadow_opa = v;
+    }
+
+    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP || dsc->shadow_opa != LV_OPA_TRANSP) {
+        dsc->radius = lv_obj_get_style_radius(obj, LV_PART_SCROLLBAR);
+        return LV_RESULT_OK;
+    }
+    else {
+        return LV_RESULT_INVALID;
+    }
+}
+
+static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
+{
+    LV_UNUSED(class_p);
+
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * obj = lv_event_get_current_target(e);
+    if(code == LV_EVENT_PRESSED) {
+        lv_obj_add_state(obj, LV_STATE_PRESSED);
+    }
+    else if(code == LV_EVENT_RELEASED) {
+        lv_obj_remove_state(obj, LV_STATE_PRESSED);
+        void * param = lv_event_get_param(e);
+        /*Go the checked state if enabled*/
+        if(lv_indev_get_scroll_obj(param) == NULL && lv_obj_has_flag(obj, LV_OBJ_FLAG_CHECKABLE)) {
+            if(!(lv_obj_get_state(obj) & LV_STATE_CHECKED)) lv_obj_add_state(obj, LV_STATE_CHECKED);
+            else lv_obj_remove_state(obj, LV_STATE_CHECKED);
+
+            lv_result_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
+            if(res != LV_RESULT_OK) return;
+        }
+    }
+    else if(code == LV_EVENT_PRESS_LOST) {
+        lv_obj_remove_state(obj, LV_STATE_PRESSED);
+    }
+    else if(code == LV_EVENT_STYLE_CHANGED) {
+        uint32_t child_cnt = lv_obj_get_child_count(obj);
+        for(uint32_t i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
+            lv_obj_mark_layout_as_dirty(child);
+        }
+    }
+    else if(code == LV_EVENT_KEY) {
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_CHECKABLE)) {
+            uint32_t c = lv_event_get_key(e);
+            if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
+                lv_obj_add_state(obj, LV_STATE_CHECKED);
+            }
+            else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
+                lv_obj_remove_state(obj, LV_STATE_CHECKED);
+            }
+
+            /*With Enter LV_EVENT_RELEASED will send VALUE_CHANGE event*/
+            if(c != LV_KEY_ENTER) {
+                lv_result_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
+                if(res != LV_RESULT_OK) return;
+            }
+        }
+        else if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLLABLE | LV_OBJ_FLAG_SCROLL_WITH_ARROW) && !lv_obj_is_editable(obj)) {
+            /*scroll by keypad or encoder*/
+            lv_anim_enable_t anim_enable = LV_ANIM_OFF;
+            int32_t sl = lv_obj_get_scroll_left(obj);
+            int32_t sr = lv_obj_get_scroll_right(obj);
+            uint32_t c = lv_event_get_key(e);
+            if(c == LV_KEY_DOWN) {
+                /*use scroll_to_x/y functions to enforce scroll limits*/
+                lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) + lv_obj_get_height(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_UP) {
+                lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) - lv_obj_get_height(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_RIGHT) {
+                /*If the object can't be scrolled horizontally then scroll it vertically*/
+                if(!((lv_obj_get_scroll_dir(obj) & LV_DIR_HOR) && (sl > 0 || sr > 0)))
+                    lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) + lv_obj_get_height(obj) / 4, anim_enable);
+                else
+                    lv_obj_scroll_to_x(obj, lv_obj_get_scroll_x(obj) + lv_obj_get_width(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_LEFT) {
+                /*If the object can't be scrolled horizontally then scroll it vertically*/
+                if(!((lv_obj_get_scroll_dir(obj) & LV_DIR_HOR) && (sl > 0 || sr > 0)))
+                    lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) - lv_obj_get_height(obj) / 4, anim_enable);
+                else
+                    lv_obj_scroll_to_x(obj, lv_obj_get_scroll_x(obj) - lv_obj_get_width(obj) / 4, anim_enable);
+            }
+        }
+    }
+    else if(code == LV_EVENT_FOCUSED) {
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_ON_FOCUS)) {
+            lv_obj_scroll_to_view_recursive(obj, LV_ANIM_ON);
+        }
+
+        bool editing = false;
+        editing = lv_group_get_editing(lv_obj_get_group(obj));
+        lv_state_t state = LV_STATE_FOCUSED;
+
+        /* Use the indev for then indev handler.
+         * But if the obj was focused manually it returns NULL so try to
+         * use the indev from the event*/
+        lv_indev_t * indev = lv_indev_active();
+        if(indev == NULL) indev = lv_event_get_indev(e);
+
+        lv_indev_type_t indev_type = lv_indev_get_type(indev);
+        if(indev_type == LV_INDEV_TYPE_KEYPAD || indev_type == LV_INDEV_TYPE_ENCODER) state |= LV_STATE_FOCUS_KEY;
+        if(editing) {
+            state |= LV_STATE_EDITED;
+            lv_obj_add_state(obj, state);
+        }
+        else {
+            lv_obj_add_state(obj, state);
+            lv_obj_remove_state(obj, LV_STATE_EDITED);
+        }
+    }
+    else if(code == LV_EVENT_SCROLL_BEGIN) {
+        lv_obj_add_state(obj, LV_STATE_SCROLLED);
+    }
+    else if(code == LV_EVENT_SCROLL_END) {
+        lv_obj_remove_state(obj, LV_STATE_SCROLLED);
+        if(lv_obj_get_scrollbar_mode(obj) == LV_SCROLLBAR_MODE_ACTIVE) {
+            lv_area_t hor_area, ver_area;
+            lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+            lv_obj_invalidate_area(obj, &hor_area);
+            lv_obj_invalidate_area(obj, &ver_area);
+        }
+    }
+    else if(code == LV_EVENT_DEFOCUSED) {
+        lv_obj_remove_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED | LV_STATE_FOCUS_KEY);
+    }
+    else if(code == LV_EVENT_SIZE_CHANGED) {
+        int32_t align = lv_obj_get_style_align(obj, LV_PART_MAIN);
+        uint16_t layout = lv_obj_get_style_layout(obj, LV_PART_MAIN);
+        if(layout || align) {
+            lv_obj_mark_layout_as_dirty(obj);
+        }
+
+        uint32_t i;
+        uint32_t child_cnt = lv_obj_get_child_count(obj);
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
+            lv_obj_mark_layout_as_dirty(child);
+        }
+    }
+    else if(code == LV_EVENT_CHILD_CHANGED) {
+        int32_t w = lv_obj_get_style_width(obj, LV_PART_MAIN);
+        int32_t h = lv_obj_get_style_height(obj, LV_PART_MAIN);
+        int32_t align = lv_obj_get_style_align(obj, LV_PART_MAIN);
+        uint16_t layout = lv_obj_get_style_layout(obj, LV_PART_MAIN);
+        if(layout || align || w == LV_SIZE_CONTENT || h == LV_SIZE_CONTENT) {
+            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) {
+        int32_t d = lv_obj_calculate_ext_draw_size(obj, LV_PART_MAIN);
+        lv_event_set_ext_draw_size(e, d);
+    }
+    else if(code == LV_EVENT_DRAW_MAIN || code == LV_EVENT_DRAW_POST || code == LV_EVENT_COVER_CHECK) {
+        lv_obj_draw(e);
+    }
+    else if(code == LV_EVENT_INDEV_RESET) {
+        lv_obj_remove_state(obj, LV_STATE_PRESSED);
+        lv_obj_remove_state(obj, LV_STATE_SCROLLED);
+    }
+    else if(code == LV_EVENT_HOVER_OVER) {
+        lv_obj_add_state(obj, LV_STATE_HOVERED);
+    }
+    else if(code == LV_EVENT_HOVER_LEAVE) {
+        lv_obj_remove_state(obj, LV_STATE_HOVERED);
+    }
+}
+
+/**
+ * Set the state (fully overwrite) of an object.
+ * If specified in the styles, transition animations will be started from the previous state to the current.
+ * @param obj       pointer to an object
+ * @param state     the new state
+ */
+static void update_obj_state(lv_obj_t * obj, lv_state_t new_state)
+{
+    if(obj->state == new_state) return;
+
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_state_t prev_state = obj->state;
+
+    lv_style_state_cmp_t cmp_res = lv_obj_style_state_compare(obj, prev_state, new_state);
+    /*If there is no difference in styles there is nothing else to do*/
+    if(cmp_res == LV_STYLE_STATE_CMP_SAME) {
+        obj->state = new_state;
+        return;
+    }
+
+    /*Invalidate the object in their current state*/
+    lv_obj_invalidate(obj);
+
+    obj->state = new_state;
+    lv_obj_update_layer_type(obj);
+    lv_obj_style_transition_dsc_t * ts = lv_malloc_zeroed(sizeof(lv_obj_style_transition_dsc_t) * STYLE_TRANSITION_MAX);
+    uint32_t tsi = 0;
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt && tsi < STYLE_TRANSITION_MAX; i++) {
+        lv_obj_style_t * obj_style = &obj->styles[i];
+        lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
+        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
+        if(state_act & (~new_state)) continue; /*Skip unrelated styles*/
+        if(obj_style->is_trans) continue;
+
+        lv_style_value_t v;
+        if(lv_style_get_prop_inlined(obj_style->style, LV_STYLE_TRANSITION, &v) != LV_STYLE_RES_FOUND) continue;
+        const lv_style_transition_dsc_t * tr = v.ptr;
+
+        /*Add the props to the set if not added yet or added but with smaller weight*/
+        uint32_t j;
+        for(j = 0; tr->props[j] != 0 && tsi < STYLE_TRANSITION_MAX; j++) {
+            uint32_t t;
+            for(t = 0; t < tsi; t++) {
+                lv_style_selector_t selector = ts[t].selector;
+                lv_state_t state_ts = lv_obj_style_get_selector_state(selector);
+                lv_part_t part_ts = lv_obj_style_get_selector_part(selector);
+                if(ts[t].prop == tr->props[j] && part_ts == part_act && state_ts >= state_act) break;
+            }
+
+            /*If not found  add it*/
+            if(t == tsi) {
+                ts[tsi].time = tr->time;
+                ts[tsi].delay = tr->delay;
+                ts[tsi].path_cb = tr->path_xcb;
+                ts[tsi].prop = tr->props[j];
+                ts[tsi].user_data = tr->user_data;
+                ts[tsi].selector = obj_style->selector;
+                tsi++;
+            }
+        }
+    }
+
+    for(i = 0; i < tsi; i++) {
+        lv_part_t part_act = lv_obj_style_get_selector_part(ts[i].selector);
+        lv_obj_style_create_transition(obj, part_act, prev_state, new_state, &ts[i]);
+    }
+
+    lv_free(ts);
+
+    if(cmp_res == LV_STYLE_STATE_CMP_DIFF_REDRAW) {
+        /*Invalidation is not enough, e.g. layer type needs to be updated too*/
+        lv_obj_refresh_style(obj, LV_PART_ANY, LV_STYLE_PROP_ANY);
+    }
+    else if(cmp_res == LV_STYLE_STATE_CMP_DIFF_LAYOUT) {
+        lv_obj_refresh_style(obj, LV_PART_ANY, LV_STYLE_PROP_ANY);
+    }
+    else if(cmp_res == LV_STYLE_STATE_CMP_DIFF_DRAW_PAD) {
+        lv_obj_invalidate(obj);
+        lv_obj_refresh_ext_draw_size(obj);
+    }
+}
+
+/**
+ * Apply the state to the children of the object
+ * @param obj pointer to an object
+ * @param state the state to apply
+ */
+static void lv_obj_children_add_state(lv_obj_t * obj, lv_state_t state)
+{
+    uint32_t child_count = lv_obj_get_child_count(obj);
+
+    for(uint32_t i = 0; i < child_count; i++) {
+        lv_obj_t * child = lv_obj_get_child(obj, i);
+        if(child) {
+            lv_obj_add_state(child, state);
+        }
+    }
+}
+
+/**
+ * Remove the state from the children of the object
+ * @param obj pointer to an object
+ * @param state the state to remove
+ */
+static void lv_obj_children_remove_state(lv_obj_t * obj, lv_state_t state)
+{
+    uint32_t child_count = lv_obj_get_child_count(obj);
+
+    for(uint32_t i = 0; i < child_count; i++) {
+        lv_obj_t * child = lv_obj_get_child(obj, i);
+        if(child) {
+            lv_obj_remove_state(child, state);
+        }
+    }
+}
+
+static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find)
+{
+    /*Check all children of `parent`*/
+    uint32_t child_cnt = 0;
+    if(parent->spec_attr) child_cnt = parent->spec_attr->child_cnt;
+    uint32_t i;
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = parent->spec_attr->children[i];
+        if(child == obj_to_find) {
+            return true;
+        }
+
+        /*Check the children*/
+        bool found = obj_valid_child(child, obj_to_find);
+        if(found) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void null_on_delete_cb(lv_event_t * e)
+{
+    lv_obj_t ** obj_ptr = lv_event_get_user_data(e);
+    *obj_ptr = NULL;
+}
+
+static void screen_load_on_trigger_event_cb(lv_event_t * e)
+{
+    screen_load_anim_dsc_t * dsc = lv_event_get_user_data(e);
+    LV_ASSERT_NULL(dsc);
+    lv_screen_load_anim(dsc->target.screen, dsc->anim_type, dsc->duration, dsc->delay, false);
+}
+
+static void screen_create_on_trigger_event_cb(lv_event_t * e)
+{
+    screen_load_anim_dsc_t * dsc = lv_event_get_user_data(e);
+    LV_ASSERT_NULL(dsc);
+
+    lv_obj_t * screen = dsc->target.create_cb();
+    lv_screen_load_anim(screen, dsc->anim_type, dsc->duration, dsc->delay, false);
+    lv_obj_add_event_cb(screen, delete_on_screen_unloaded_event_cb, LV_EVENT_SCREEN_UNLOADED, NULL);
+}
+
+static void play_timeline_on_trigger_event_cb(lv_event_t * e)
+{
+    timeline_play_dsc_t * dsc = lv_event_get_user_data(e);
+    LV_ASSERT_NULL(dsc);
+
+    /*Reset the progress only if the animation was finished*/
+    uint16_t progress = lv_anim_timeline_get_progress(dsc->at);
+    if(dsc->reverse) {
+        if(progress == 0) {
+            lv_anim_timeline_set_progress(dsc->at, LV_ANIM_TIMELINE_PROGRESS_MAX);
+        }
+
+        if(lv_anim_timeline_get_progress(dsc->at) == LV_ANIM_TIMELINE_PROGRESS_MAX) {
+            lv_anim_timeline_set_delay(dsc->at, dsc->delay);
+        }
+
+        lv_anim_timeline_set_reverse(dsc->at, true);
+    }
+    else {
+        if(progress == LV_ANIM_TIMELINE_PROGRESS_MAX) {
+            lv_anim_timeline_set_progress(dsc->at, 0);
+        }
+
+        if(lv_anim_timeline_get_progress(dsc->at) == 0) {
+            lv_anim_timeline_set_delay(dsc->at, dsc->delay);
+        }
+
+        lv_anim_timeline_set_reverse(dsc->at, false);
+    }
+    lv_anim_timeline_start(dsc->at);
+}
+
+
+static void delete_on_screen_unloaded_event_cb(lv_event_t * e)
+{
+    lv_obj_delete(lv_event_get_target_obj(e));
+}
+
+#if LV_USE_OBJ_PROPERTY
+static lv_result_t lv_obj_set_any(lv_obj_t * obj, lv_prop_id_t id, const lv_property_t * prop)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(id >= LV_PROPERTY_OBJ_FLAG_START && id <= LV_PROPERTY_OBJ_FLAG_END) {
+        lv_obj_flag_t flag = 1L << (id - LV_PROPERTY_OBJ_FLAG_START);
+        if(prop->num) lv_obj_add_flag(obj, flag);
+        else lv_obj_remove_flag(obj, flag);
+        return LV_RESULT_OK;
+    }
+    else if(id >= LV_PROPERTY_OBJ_STATE_START && id <= LV_PROPERTY_OBJ_STATE_END) {
+        lv_state_t state = 1L << (id - LV_PROPERTY_OBJ_STATE_START);
+        if(id == LV_PROPERTY_OBJ_STATE_ANY) {
+            state = LV_STATE_ANY;
+        }
+
+        if(prop->num) lv_obj_add_state(obj, state);
+        else lv_obj_remove_state(obj, state);
+        return LV_RESULT_OK;
+    }
+    else {
+        return LV_RESULT_INVALID;
+    }
+}
+
+static lv_result_t lv_obj_get_any(const lv_obj_t * obj, lv_prop_id_t id, lv_property_t * prop)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(id >= LV_PROPERTY_OBJ_FLAG_START && id <= LV_PROPERTY_OBJ_FLAG_END) {
+        lv_obj_flag_t flag = 1L << (id - LV_PROPERTY_OBJ_FLAG_START);
+        prop->id = id;
+        prop->num = obj->flags & flag;
+        return LV_RESULT_OK;
+    }
+    else if(id >= LV_PROPERTY_OBJ_STATE_START && id <= LV_PROPERTY_OBJ_STATE_END) {
+        prop->id = id;
+        if(id == LV_PROPERTY_OBJ_STATE_ANY) {
+            prop->num = obj->state;
+        }
+        else {
+            lv_obj_flag_t flag = 1L << (id - LV_PROPERTY_OBJ_STATE_START);
+            prop->num = obj->state & flag;
+        }
+        return LV_RESULT_OK;
+    }
+    else {
+        return LV_RESULT_INVALID;
+    }
+}
+#endif

components/easylvgl/lvgl9/src/core/lv_obj.h

@@ -0,0 +1,486 @@
+/**
+ * @file lv_obj.h
+ *
+ */
+
+#ifndef LV_OBJ_H
+#define LV_OBJ_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#include "../misc/lv_types.h"
+#include "../misc/lv_style.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_assert.h"
+
+#include "lv_obj_tree.h"
+#include "lv_obj_pos.h"
+#include "lv_obj_scroll.h"
+#include "lv_obj_style.h"
+#include "lv_obj_draw.h"
+#include "lv_obj_class.h"
+#include "lv_obj_event.h"
+#include "lv_obj_property.h"
+#include "lv_group.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+/**
+ * On/Off features controlling the object's behavior.
+ * OR-ed values are possible
+ *
+ * Note: update obj flags corresponding properties below
+ * whenever add/remove flags or change bit definition of flags.
+ */
+typedef enum {
+    LV_OBJ_FLAG_HIDDEN          = (1L << 0),  /**< Make the object hidden. (Like it wasn't there at all)*/
+    LV_OBJ_FLAG_CLICKABLE       = (1L << 1),  /**< Make the object clickable by the input devices*/
+    LV_OBJ_FLAG_CLICK_FOCUSABLE = (1L << 2),  /**< Add focused state to the object when clicked*/
+    LV_OBJ_FLAG_CHECKABLE       = (1L << 3),  /**< Toggle checked state when the object is clicked*/
+    LV_OBJ_FLAG_SCROLLABLE      = (1L << 4),  /**< Make the object scrollable*/
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1L << 5),  /**< Allow scrolling inside but with slower speed*/
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1L << 6),  /**< Make the object scroll further when "thrown"*/
+    LV_OBJ_FLAG_SCROLL_ONE      = (1L << 7),  /**< Allow scrolling only one snappable children*/
+    LV_OBJ_FLAG_SCROLL_CHAIN_HOR = (1L << 8), /**< Allow propagating the horizontal scroll to a parent*/
+    LV_OBJ_FLAG_SCROLL_CHAIN_VER = (1L << 9), /**< Allow propagating the vertical scroll to a parent*/
+    LV_OBJ_FLAG_SCROLL_CHAIN     = (LV_OBJ_FLAG_SCROLL_CHAIN_HOR | LV_OBJ_FLAG_SCROLL_CHAIN_VER),
+    LV_OBJ_FLAG_SCROLL_ON_FOCUS = (1L << 10),  /**< Automatically scroll object to make it visible when focused*/
+    LV_OBJ_FLAG_SCROLL_WITH_ARROW  = (1L << 11), /**< Allow scrolling the focused object with arrow keys*/
+    LV_OBJ_FLAG_SNAPPABLE       = (1L << 12), /**< If scroll snap is enabled on the parent it can snap to this object*/
+    LV_OBJ_FLAG_PRESS_LOCK      = (1L << 13), /**< Keep the object pressed even if the press slid from the object*/
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1L << 14), /**< Propagate the events to the parent too*/
+    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1L << 15), /**< Propagate the gestures to the parent*/
+    LV_OBJ_FLAG_ADV_HITTEST     = (1L << 16), /**< Allow performing more accurate hit (click) test. E.g. consider rounded corners.*/
+    LV_OBJ_FLAG_IGNORE_LAYOUT   = (1L << 17), /**< Make the object not positioned by the layouts*/
+    LV_OBJ_FLAG_FLOATING        = (1L << 18), /**< Do not scroll the object when the parent scrolls and ignore layout*/
+    LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS = (1L << 19), /**< Send `LV_EVENT_DRAW_TASK_ADDED` events*/
+    LV_OBJ_FLAG_OVERFLOW_VISIBLE = (1L << 20),/**< Do not clip the children to the parent's ext draw size*/
+    LV_OBJ_FLAG_EVENT_TRICKLE   = (1L << 21), /**< Propagate the events to the children too*/
+    LV_OBJ_FLAG_STATE_TRICKLE   = (1L << 22), /**< Propagate the states to the children too*/
+
+    LV_OBJ_FLAG_LAYOUT_1        = (1L << 23), /**< Custom flag, free to use by layouts*/
+    LV_OBJ_FLAG_LAYOUT_2        = (1L << 24), /**< Custom flag, free to use by layouts*/
+#if LV_USE_FLEX
+    LV_OBJ_FLAG_FLEX_IN_NEW_TRACK = LV_OBJ_FLAG_LAYOUT_1,     /**< Start a new flex track on this item*/
+#endif
+
+    LV_OBJ_FLAG_WIDGET_1        = (1L << 25), /**< Custom flag, free to use by widget*/
+    LV_OBJ_FLAG_WIDGET_2        = (1L << 26), /**< Custom flag, free to use by widget*/
+    LV_OBJ_FLAG_USER_1          = (1L << 27), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_2          = (1L << 28), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_3          = (1L << 29), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_4          = (1L << 30), /**< Custom flag, free to use by user*/
+} lv_obj_flag_t;
+
+#if LV_USE_OBJ_PROPERTY
+enum _lv_signed_prop_id_t {
+    /*OBJ flag properties */
+    LV_PROPERTY_ID(OBJ, FLAG_START,                 LV_PROPERTY_TYPE_INT,       0),
+    LV_PROPERTY_ID(OBJ, FLAG_HIDDEN,                LV_PROPERTY_TYPE_INT,       0),
+    LV_PROPERTY_ID(OBJ, FLAG_CLICKABLE,             LV_PROPERTY_TYPE_INT,       1),
+    LV_PROPERTY_ID(OBJ, FLAG_CLICK_FOCUSABLE,       LV_PROPERTY_TYPE_INT,       2),
+    LV_PROPERTY_ID(OBJ, FLAG_CHECKABLE,             LV_PROPERTY_TYPE_INT,       3),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLLABLE,            LV_PROPERTY_TYPE_INT,       4),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_ELASTIC,        LV_PROPERTY_TYPE_INT,       5),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_MOMENTUM,       LV_PROPERTY_TYPE_INT,       6),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_ONE,            LV_PROPERTY_TYPE_INT,       7),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_CHAIN_HOR,      LV_PROPERTY_TYPE_INT,       8),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_CHAIN_VER,      LV_PROPERTY_TYPE_INT,       9),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_ON_FOCUS,       LV_PROPERTY_TYPE_INT,       10),
+    LV_PROPERTY_ID(OBJ, FLAG_SCROLL_WITH_ARROW,     LV_PROPERTY_TYPE_INT,       11),
+    LV_PROPERTY_ID(OBJ, FLAG_SNAPPABLE,             LV_PROPERTY_TYPE_INT,       12),
+    LV_PROPERTY_ID(OBJ, FLAG_PRESS_LOCK,            LV_PROPERTY_TYPE_INT,       13),
+    LV_PROPERTY_ID(OBJ, FLAG_EVENT_BUBBLE,          LV_PROPERTY_TYPE_INT,       14),
+    LV_PROPERTY_ID(OBJ, FLAG_GESTURE_BUBBLE,        LV_PROPERTY_TYPE_INT,       15),
+    LV_PROPERTY_ID(OBJ, FLAG_ADV_HITTEST,           LV_PROPERTY_TYPE_INT,       16),
+    LV_PROPERTY_ID(OBJ, FLAG_IGNORE_LAYOUT,         LV_PROPERTY_TYPE_INT,       17),
+    LV_PROPERTY_ID(OBJ, FLAG_FLOATING,              LV_PROPERTY_TYPE_INT,       18),
+    LV_PROPERTY_ID(OBJ, FLAG_SEND_DRAW_TASK_EVENTS, LV_PROPERTY_TYPE_INT,       19),
+    LV_PROPERTY_ID(OBJ, FLAG_OVERFLOW_VISIBLE,      LV_PROPERTY_TYPE_INT,       20),
+    LV_PROPERTY_ID(OBJ, FLAG_EVENT_TRICKLE,         LV_PROPERTY_TYPE_INT,       21),
+    LV_PROPERTY_ID(OBJ, FLAG_STATE_TRICKLE,         LV_PROPERTY_TYPE_INT,       22),
+    LV_PROPERTY_ID(OBJ, FLAG_LAYOUT_1,              LV_PROPERTY_TYPE_INT,       23),
+    LV_PROPERTY_ID(OBJ, FLAG_LAYOUT_2,              LV_PROPERTY_TYPE_INT,       24),
+    LV_PROPERTY_ID(OBJ, FLAG_FLEX_IN_NEW_TRACK,     LV_PROPERTY_TYPE_INT,       23), /*Mapped to FLAG_LAYOUT_1*/
+    LV_PROPERTY_ID(OBJ, FLAG_WIDGET_1,              LV_PROPERTY_TYPE_INT,       25),
+    LV_PROPERTY_ID(OBJ, FLAG_WIDGET_2,              LV_PROPERTY_TYPE_INT,       26),
+    LV_PROPERTY_ID(OBJ, FLAG_USER_1,                LV_PROPERTY_TYPE_INT,       27),
+    LV_PROPERTY_ID(OBJ, FLAG_USER_2,                LV_PROPERTY_TYPE_INT,       28),
+    LV_PROPERTY_ID(OBJ, FLAG_USER_3,                LV_PROPERTY_TYPE_INT,       29),
+    LV_PROPERTY_ID(OBJ, FLAG_USER_4,                LV_PROPERTY_TYPE_INT,       30),
+    LV_PROPERTY_ID(OBJ, FLAG_END,                   LV_PROPERTY_TYPE_INT,       30),
+
+    LV_PROPERTY_ID(OBJ, STATE_START,                LV_PROPERTY_TYPE_INT,       31),
+    LV_PROPERTY_ID(OBJ, STATE_CHECKED,              LV_PROPERTY_TYPE_INT,       31),
+    LV_PROPERTY_ID(OBJ, STATE_FOCUSED,              LV_PROPERTY_TYPE_INT,       32),
+    LV_PROPERTY_ID(OBJ, STATE_FOCUS_KEY,            LV_PROPERTY_TYPE_INT,       33),
+    LV_PROPERTY_ID(OBJ, STATE_EDITED,               LV_PROPERTY_TYPE_INT,       34),
+    LV_PROPERTY_ID(OBJ, STATE_HOVERED,              LV_PROPERTY_TYPE_INT,       35),
+    LV_PROPERTY_ID(OBJ, STATE_PRESSED,              LV_PROPERTY_TYPE_INT,       36),
+    LV_PROPERTY_ID(OBJ, STATE_SCROLLED,             LV_PROPERTY_TYPE_INT,       37),
+    LV_PROPERTY_ID(OBJ, STATE_DISABLED,             LV_PROPERTY_TYPE_INT,       38),
+    /*not used bit8-bit11*/
+    LV_PROPERTY_ID(OBJ, STATE_USER_1,               LV_PROPERTY_TYPE_INT,       43),
+    LV_PROPERTY_ID(OBJ, STATE_USER_2,               LV_PROPERTY_TYPE_INT,       44),
+    LV_PROPERTY_ID(OBJ, STATE_USER_3,               LV_PROPERTY_TYPE_INT,       45),
+    LV_PROPERTY_ID(OBJ, STATE_USER_4,               LV_PROPERTY_TYPE_INT,       46),
+    LV_PROPERTY_ID(OBJ, STATE_ANY,                  LV_PROPERTY_TYPE_INT,       47),
+    LV_PROPERTY_ID(OBJ, STATE_END,                  LV_PROPERTY_TYPE_INT,       47),
+
+    /*OBJ normal properties*/
+    LV_PROPERTY_ID(OBJ, PARENT,                     LV_PROPERTY_TYPE_OBJ,       48),
+    LV_PROPERTY_ID(OBJ, X,                          LV_PROPERTY_TYPE_INT,       49),
+    LV_PROPERTY_ID(OBJ, Y,                          LV_PROPERTY_TYPE_INT,       50),
+    LV_PROPERTY_ID(OBJ, W,                          LV_PROPERTY_TYPE_INT,       51),
+    LV_PROPERTY_ID(OBJ, H,                          LV_PROPERTY_TYPE_INT,       52),
+    LV_PROPERTY_ID(OBJ, CONTENT_WIDTH,              LV_PROPERTY_TYPE_INT,       53),
+    LV_PROPERTY_ID(OBJ, CONTENT_HEIGHT,             LV_PROPERTY_TYPE_INT,       54),
+    LV_PROPERTY_ID(OBJ, LAYOUT,                     LV_PROPERTY_TYPE_INT,       55),
+    LV_PROPERTY_ID(OBJ, ALIGN,                      LV_PROPERTY_TYPE_INT,       56),
+    LV_PROPERTY_ID(OBJ, SCROLLBAR_MODE,             LV_PROPERTY_TYPE_INT,       57),
+    LV_PROPERTY_ID(OBJ, SCROLL_DIR,                 LV_PROPERTY_TYPE_INT,       58),
+    LV_PROPERTY_ID(OBJ, SCROLL_SNAP_X,              LV_PROPERTY_TYPE_INT,       59),
+    LV_PROPERTY_ID(OBJ, SCROLL_SNAP_Y,              LV_PROPERTY_TYPE_INT,       60),
+    LV_PROPERTY_ID(OBJ, SCROLL_X,                   LV_PROPERTY_TYPE_INT,       61),
+    LV_PROPERTY_ID(OBJ, SCROLL_Y,                   LV_PROPERTY_TYPE_INT,       62),
+    LV_PROPERTY_ID(OBJ, SCROLL_TOP,                 LV_PROPERTY_TYPE_INT,       63),
+    LV_PROPERTY_ID(OBJ, SCROLL_BOTTOM,              LV_PROPERTY_TYPE_INT,       64),
+    LV_PROPERTY_ID(OBJ, SCROLL_LEFT,                LV_PROPERTY_TYPE_INT,       65),
+    LV_PROPERTY_ID(OBJ, SCROLL_RIGHT,               LV_PROPERTY_TYPE_INT,       66),
+    LV_PROPERTY_ID(OBJ, SCROLL_END,                 LV_PROPERTY_TYPE_INT,       67),
+    LV_PROPERTY_ID(OBJ, EXT_DRAW_SIZE,              LV_PROPERTY_TYPE_INT,       68),
+    LV_PROPERTY_ID(OBJ, EVENT_COUNT,                LV_PROPERTY_TYPE_INT,       69),
+    LV_PROPERTY_ID(OBJ, SCREEN,                     LV_PROPERTY_TYPE_OBJ,       70),
+    LV_PROPERTY_ID(OBJ, DISPLAY,                    LV_PROPERTY_TYPE_POINTER,   71),
+    LV_PROPERTY_ID(OBJ, CHILD_COUNT,                LV_PROPERTY_TYPE_INT,       72),
+    LV_PROPERTY_ID(OBJ, INDEX,                      LV_PROPERTY_TYPE_INT,       73),
+
+    LV_PROPERTY_OBJ_END,
+};
+#endif
+
+/**
+ * Make the base object's class publicly available.
+ */
+LV_ATTRIBUTE_EXTERN_DATA extern const lv_obj_class_t lv_obj_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a base object (a rectangle)
+ * @param parent    pointer to a parent object. If NULL then a screen will be created.
+ * @return          pointer to the new object
+ */
+lv_obj_t * lv_obj_create(lv_obj_t * parent);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set one or more flags
+ * @param obj   pointer to an object
+ * @param f     OR-ed values from `lv_obj_flag_t` to set.
+ */
+void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f);
+
+/**
+ * Remove one or more flags
+ * @param obj   pointer to an object
+ * @param f     OR-ed values from `lv_obj_flag_t` to clear.
+ */
+void lv_obj_remove_flag(lv_obj_t * obj, lv_obj_flag_t f);
+
+/**
+ * Set add or remove one or more flags.
+ * @param obj   pointer to an object
+ * @param f     OR-ed values from `lv_obj_flag_t` to update.
+ * @param v     true: add the flags; false: remove the flags
+ */
+void lv_obj_set_flag(lv_obj_t * obj, lv_obj_flag_t f, bool v);
+
+/**
+ * Add one or more states to the object. The other state bits will remain unchanged.
+ * If specified in the styles, transition animation will be started from the previous state to the current.
+ * @param obj       pointer to an object
+ * @param state     the states to add. E.g `LV_STATE_PRESSED | LV_STATE_FOCUSED`
+ */
+void lv_obj_add_state(lv_obj_t * obj, lv_state_t state);
+
+/**
+ * Remove one or more states to the object. The other state bits will remain unchanged.
+ * If specified in the styles, transition animation will be started from the previous state to the current.
+ * @param obj       pointer to an object
+ * @param state     the states to add. E.g `LV_STATE_PRESSED | LV_STATE_FOCUSED`
+ */
+void lv_obj_remove_state(lv_obj_t * obj, lv_state_t state);
+
+/**
+ * Add or remove one or more states to the object. The other state bits will remain unchanged.
+ * @param obj       pointer to an object
+ * @param state     the states to add. E.g `LV_STATE_PRESSED | LV_STATE_FOCUSED`
+ * @param v         true: add the states; false: remove the states
+ */
+void lv_obj_set_state(lv_obj_t * obj, lv_state_t state, bool v);
+
+/**
+ * Set the user_data field of the object
+ * @param obj   pointer to an object
+ * @param user_data   pointer to the new user_data.
+ */
+void lv_obj_set_user_data(lv_obj_t * obj, void * user_data);
+
+/*=======================
+ * Getter functions
+ *======================*/
+
+/**
+ * Check if a given flag or all the given flags are set on an object.
+ * @param obj   pointer to an object
+ * @param f     the flag(s) to check (OR-ed values can be used)
+ * @return      true: all flags are set; false: not all flags are set
+ */
+bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f);
+
+/**
+ * Check if a given flag or any of the flags are set on an object.
+ * @param obj   pointer to an object
+ * @param f     the flag(s) to check (OR-ed values can be used)
+ * @return      true: at least one flag is set; false: none of the flags are set
+ */
+bool lv_obj_has_flag_any(const lv_obj_t * obj, lv_obj_flag_t f);
+
+/**
+ * Get the state of an object
+ * @param obj   pointer to an object
+ * @return      the state (OR-ed values from `lv_state_t`)
+ */
+lv_state_t lv_obj_get_state(const lv_obj_t * obj);
+
+/**
+ * Check if the object is in a given state or not.
+ * @param obj       pointer to an object
+ * @param state     a state or combination of states to check
+ * @return          true: `obj` is in `state`; false: `obj` is not in `state`
+ */
+bool lv_obj_has_state(const lv_obj_t * obj, lv_state_t state);
+
+/**
+ * Get the group of the object
+ * @param       obj pointer to an object
+ * @return      the pointer to group of the object
+ */
+lv_group_t * lv_obj_get_group(const lv_obj_t * obj);
+
+/**
+ * Get the user_data field of the object
+ * @param obj   pointer to an object
+ * @return      the pointer to the user_data of the object
+ */
+void * lv_obj_get_user_data(lv_obj_t * obj);
+
+/*=======================
+ * Other functions
+ *======================*/
+
+/**
+ * Allocate special data for an object if not allocated yet.
+ * @param obj   pointer to an object
+ */
+void lv_obj_allocate_spec_attr(lv_obj_t * obj);
+
+/**
+ * Check the type of obj.
+ * @param obj       pointer to an object
+ * @param class_p   a class to check (e.g. `lv_slider_class`)
+ * @return          true: `class_p` is the `obj` class.
+ */
+bool lv_obj_check_type(const lv_obj_t * obj, const lv_obj_class_t * class_p);
+
+/**
+ * Check if any object has a given class (type).
+ * It checks the ancestor classes too.
+ * @param obj       pointer to an object
+ * @param class_p   a class to check (e.g. `lv_slider_class`)
+ * @return          true: `obj` has the given class
+ */
+bool lv_obj_has_class(const lv_obj_t * obj, const lv_obj_class_t * class_p);
+
+/**
+ * Get the class (type) of the object
+ * @param obj   pointer to an object
+ * @return      the class (type) of the object
+ */
+const lv_obj_class_t * lv_obj_get_class(const lv_obj_t * obj);
+
+/**
+ * Check if any object is still "alive".
+ * @param obj       pointer to an object
+ * @return          true: valid
+ */
+bool lv_obj_is_valid(const lv_obj_t * obj);
+
+/**
+ * Utility to set an object reference to NULL when it gets deleted.
+ * The reference should be in a location that will not become invalid
+ * during the object's lifetime, i.e. static or allocated.
+ * @param obj_ptr   a pointer to a pointer to an object
+ */
+void lv_obj_null_on_delete(lv_obj_t ** obj_ptr);
+
+/**
+ * Add an event handler to a widget that will load a screen on a trigger.
+ * @param obj           pointer to widget which should load the screen
+ * @param trigger       an event code, e.g. `LV_EVENT_CLICKED`
+ * @param screen        the screen to load (must be a valid widget)
+ * @param anim_type     element of `lv_screen_load_anim_t` the screen load animation
+ * @param duration      duration of the animation in milliseconds
+ * @param delay         delay before the screen load in milliseconds
+ */
+void lv_obj_add_screen_load_event(lv_obj_t * obj, lv_event_code_t trigger, lv_obj_t * screen,
+                                  lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay);
+
+/**
+ * Add an event handler to a widget that will create a screen on a trigger.
+ * The created screen will be deleted when it's unloaded
+ * @param obj               pointer to widget which should load the screen
+ * @param trigger           an event code, e.g. `LV_EVENT_CLICKED`
+ * @param screen_create_cb  a callback to create the screen, e.g. `lv_obj_t * myscreen_create(void)`
+ * @param anim_type         element of `lv_screen_load_anim_t` the screen load animation
+ * @param duration          duration of the animation in milliseconds
+ * @param delay             delay before the screen load in milliseconds
+ */
+void lv_obj_add_screen_create_event(lv_obj_t * obj, lv_event_code_t trigger, lv_screen_create_cb_t screen_create_cb,
+                                    lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay);
+
+
+/**
+ * Play a timeline animation on a trigger
+ * @param obj               pointer to widget which should trigger playing the animation
+ * @param trigger           an event code, e.g. `LV_EVENT_CLICKED`
+ * @param at                pointer to an animation timeline
+ * @param delay             wait time before starting the animation
+ * @param reverse           true: play in reverse
+ */
+void lv_obj_add_play_timeline_event(lv_obj_t * obj, lv_event_code_t trigger, lv_anim_timeline_t * at, uint32_t delay,
+                                    bool reverse);
+
+#if LV_USE_OBJ_ID
+/**
+ * Set an id for an object.
+ * @param obj   pointer to an object
+ * @param id    the id of the object
+ */
+void lv_obj_set_id(lv_obj_t * obj, void * id);
+
+/**
+ * Get the id of an object.
+ * @param obj   pointer to an object
+ * @return      the id of the object
+ */
+void * lv_obj_get_id(const lv_obj_t * obj);
+
+/**
+ * DEPRECATED IDs are used only to print the widget trees.
+ * To find a widget use `lv_obj_find_by_name`
+ *
+ * Get the child object by its id.
+ * It will check children and grandchildren recursively.
+ * Function `lv_obj_id_compare` is used to matched obj id with given id.
+ *
+ * @param obj       pointer to an object
+ * @param id        the id of the child object
+ * @return          pointer to the child object or NULL if not found
+ */
+lv_obj_t * lv_obj_find_by_id(const lv_obj_t * obj, const void * id);
+
+/**
+ * Assign id to object if not previously assigned.
+ * This function gets called automatically when LV_OBJ_ID_AUTO_ASSIGN is enabled.
+ *
+ * Set `LV_USE_OBJ_ID_BUILTIN` to use the builtin method to generate object ID.
+ * Otherwise, these functions including `lv_obj_[set|assign|free|stringify]_id` and
+ * `lv_obj_id_compare`should be implemented externally.
+ *
+ * @param class_p   the class this obj belongs to. Note obj->class_p is the class currently being constructed.
+ * @param obj   pointer to an object
+ */
+void lv_obj_assign_id(const lv_obj_class_t * class_p, lv_obj_t * obj);
+
+/**
+ * Free resources allocated by `lv_obj_assign_id` or `lv_obj_set_id`.
+ * This function is also called automatically when object is deleted.
+ * @param obj   pointer to an object
+ */
+void lv_obj_free_id(lv_obj_t * obj);
+
+/**
+ * Compare two obj id, return 0 if they are equal.
+ *
+ * Set `LV_USE_OBJ_ID_BUILTIN` to use the builtin method for compare.
+ * Otherwise, it must be implemented externally.
+ *
+ * @param id1: the first id
+ * @param id2: the second id
+ * @return     0 if they are equal, non-zero otherwise.
+ */
+int lv_obj_id_compare(const void * id1, const void * id2);
+
+/**
+ * Format an object's id into a string.
+ * @param obj   pointer to an object
+ * @param buf   buffer to write the string into
+ * @param len   length of the buffer
+ */
+const char * lv_obj_stringify_id(lv_obj_t * obj, char * buf, uint32_t len);
+
+#if LV_USE_OBJ_ID_BUILTIN
+/**
+ * Free resources used by builtin ID generator.
+ */
+void lv_objid_builtin_destroy(void);
+#endif
+
+#endif /*LV_USE_OBJ_ID*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#if LV_USE_ASSERT_OBJ
+#  define LV_ASSERT_OBJ(obj_p, obj_class)                                                               \
+    do {                                                                                                \
+        LV_ASSERT_MSG(obj_p != NULL, "The object is NULL");                                             \
+        LV_ASSERT_MSG(lv_obj_has_class(obj_p, obj_class) == true, "Incompatible object type.");         \
+        LV_ASSERT_MSG(lv_obj_is_valid(obj_p)  == true, "The object is invalid, deleted or corrupted?"); \
+    } while(0)
+# else
+#  define LV_ASSERT_OBJ(obj_p, obj_class) LV_ASSERT_NULL(obj_p)
+#endif
+
+#if LV_USE_LOG && LV_LOG_TRACE_OBJ_CREATE
+#  define LV_TRACE_OBJ_CREATE(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+#  define LV_TRACE_OBJ_CREATE(...)
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_H*/

components/easylvgl/lvgl9/src/core/lv_obj_class.c

@@ -0,0 +1,204 @@
+/**
+ * @file lv_obj_class.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_class_private.h"
+#include "lv_obj_private.h"
+#include "../themes/lv_theme.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_obj_construct(const lv_obj_class_t * class_p, lv_obj_t * obj);
+static uint32_t get_instance_size(const lv_obj_class_t * class_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * parent)
+{
+    LV_TRACE_OBJ_CREATE("Creating object with %p class on %p parent", (void *)class_p, (void *)parent);
+    uint32_t s = get_instance_size(class_p);
+    lv_obj_t * obj = lv_malloc_zeroed(s);
+    if(obj == NULL) return NULL;
+    obj->class_p = class_p;
+    obj->parent = parent;
+
+    /*Create a screen*/
+    if(parent == NULL) {
+        LV_TRACE_OBJ_CREATE("creating a screen");
+        lv_display_t * disp = lv_display_get_default();
+        if(!disp) {
+            LV_LOG_WARN("No display created yet. No place to assign the new screen");
+            lv_free(obj);
+            return NULL;
+        }
+
+        if(disp->screens == NULL) {
+            disp->screen_cnt = 0;
+        }
+
+        lv_obj_t ** screens = lv_realloc(disp->screens, sizeof(lv_obj_t *) * (disp->screen_cnt + 1));
+        LV_ASSERT_MALLOC(screens);
+        if(screens == NULL) {
+            lv_free(obj);
+            return NULL;
+        }
+
+        disp->screen_cnt++;
+        disp->screens = screens;
+        disp->screens[disp->screen_cnt - 1] = obj;
+
+        /*Set coordinates to full screen size*/
+        obj->coords.x1 = 0;
+        obj->coords.y1 = 0;
+        obj->coords.x2 = lv_display_get_horizontal_resolution(NULL) - 1;
+        obj->coords.y2 = lv_display_get_vertical_resolution(NULL) - 1;
+    }
+    /*Create a normal object*/
+    else {
+        LV_TRACE_OBJ_CREATE("creating normal object");
+        LV_ASSERT_OBJ(parent, MY_CLASS);
+        if(parent->spec_attr == NULL) {
+            lv_obj_allocate_spec_attr(parent);
+        }
+
+        parent->spec_attr->child_cnt++;
+        parent->spec_attr->children = lv_realloc(parent->spec_attr->children,
+                                                 sizeof(lv_obj_t *) * parent->spec_attr->child_cnt);
+        parent->spec_attr->children[parent->spec_attr->child_cnt - 1] = obj;
+    }
+
+    return obj;
+}
+
+void lv_obj_class_init_obj(lv_obj_t * obj)
+{
+    if(obj == NULL) return;
+
+    lv_obj_mark_layout_as_dirty(obj);
+    lv_obj_enable_style_refresh(false);
+
+    lv_theme_apply(obj);
+    lv_obj_construct(obj->class_p, obj);
+
+    lv_obj_enable_style_refresh(true);
+    lv_obj_refresh_style(obj, LV_PART_ANY, LV_STYLE_PROP_ANY);
+
+    lv_obj_refresh_self_size(obj);
+
+    lv_group_t * def_group = lv_group_get_default();
+    if(def_group && lv_obj_is_group_def(obj)) {
+        lv_group_add_obj(def_group, obj);
+    }
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        /*Call the ancestor's event handler to the parent to notify it about the new child.
+         *Also triggers layout update*/
+        lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, obj);
+        lv_obj_send_event(parent, LV_EVENT_CHILD_CREATED, obj);
+
+        /*Invalidate the area if not screen created*/
+        lv_obj_invalidate(obj);
+    }
+}
+
+void lv_obj_destruct(lv_obj_t * obj)
+{
+    if(obj->class_p->destructor_cb) obj->class_p->destructor_cb(obj->class_p, obj);
+
+    if(obj->class_p->base_class) {
+        /*Don't let the descendant methods run during destructing the ancestor type*/
+        obj->class_p = obj->class_p->base_class;
+
+        /*Call the base class's destructor too*/
+        lv_obj_destruct(obj);
+    }
+}
+
+bool lv_obj_is_editable(lv_obj_t * obj)
+{
+    const lv_obj_class_t * class_p = obj->class_p;
+
+    /*Find a base in which editable is set*/
+    while(class_p && class_p->editable == LV_OBJ_CLASS_EDITABLE_INHERIT) class_p = class_p->base_class;
+
+    if(class_p == NULL) return false;
+
+    return class_p->editable == LV_OBJ_CLASS_EDITABLE_TRUE;
+}
+
+bool lv_obj_is_group_def(lv_obj_t * obj)
+{
+    const lv_obj_class_t * class_p = obj->class_p;
+
+    /*Find a base in which group_def is set*/
+    while(class_p && class_p->group_def == LV_OBJ_CLASS_GROUP_DEF_INHERIT) class_p = class_p->base_class;
+
+    if(class_p == NULL) return false;
+
+    return class_p->group_def == LV_OBJ_CLASS_GROUP_DEF_TRUE;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_obj_construct(const lv_obj_class_t * class_p, lv_obj_t * obj)
+{
+    if(obj->class_p->base_class) {
+        const lv_obj_class_t * original_class_p = obj->class_p;
+
+        /*Don't let the descendant methods run during constructing the ancestor type*/
+        obj->class_p = obj->class_p->base_class;
+
+        /*Construct the base first*/
+        lv_obj_construct(class_p, obj);
+
+        /*Restore the original class*/
+        obj->class_p = original_class_p;
+    }
+
+    if(obj->class_p->constructor_cb) obj->class_p->constructor_cb(class_p, obj);
+}
+
+static uint32_t get_instance_size(const lv_obj_class_t * class_p)
+{
+    /*Find a base in which instance size is set*/
+    const lv_obj_class_t * base = class_p;
+    while(base && base->instance_size == 0) base = base->base_class;
+
+    if(base == NULL) return 0;  /*Never happens: set at least in `lv_obj` class*/
+
+    return base->instance_size;
+}

components/easylvgl/lvgl9/src/core/lv_obj_class.h

@@ -0,0 +1,72 @@
+/**
+ * @file lv_obj_class.h
+ *
+ */
+
+#ifndef LV_OBJ_CLASS_H
+#define LV_OBJ_CLASS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_area.h"
+#include "lv_obj_property.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_OBJ_CLASS_EDITABLE_INHERIT,      /**< Check the base class. Must have 0 value to let zero initialized class inherit*/
+    LV_OBJ_CLASS_EDITABLE_TRUE,
+    LV_OBJ_CLASS_EDITABLE_FALSE,
+} lv_obj_class_editable_t;
+
+typedef enum {
+    LV_OBJ_CLASS_GROUP_DEF_INHERIT,      /**< Check the base class. Must have 0 value to let zero initialized class inherit*/
+    LV_OBJ_CLASS_GROUP_DEF_TRUE,
+    LV_OBJ_CLASS_GROUP_DEF_FALSE,
+} lv_obj_class_group_def_t;
+
+typedef enum {
+    LV_OBJ_CLASS_THEME_INHERITABLE_FALSE,    /**< Do not inherit theme from base class. */
+    LV_OBJ_CLASS_THEME_INHERITABLE_TRUE,
+} lv_obj_class_theme_inheritable_t;
+
+typedef void (*lv_obj_class_event_cb_t)(lv_obj_class_t * class_p, lv_event_t * e);
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create an object form a class descriptor
+ * @param class_p   pointer to a class
+ * @param parent    pointer to an object where the new object should be created
+ * @return          pointer to the created object
+ */
+lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * parent);
+
+void lv_obj_class_init_obj(lv_obj_t * obj);
+
+bool lv_obj_is_editable(lv_obj_t * obj);
+
+bool lv_obj_is_group_def(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_CLASS_H*/

components/easylvgl/lvgl9/src/core/lv_obj_class_private.h

@@ -0,0 +1,78 @@
+/**
+ * @file lv_obj_class_private.h
+ *
+ */
+
+#ifndef LV_OBJ_CLASS_PRIVATE_H
+#define LV_OBJ_CLASS_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj_class.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Describe the common methods of every object.
+ * Similar to a C++ class.
+ */
+struct _lv_obj_class_t {
+    const lv_obj_class_t * base_class;
+    /** class_p is the final class while obj->class_p is the class currently being [de]constructed. */
+    void (*constructor_cb)(const lv_obj_class_t * class_p, lv_obj_t * obj);
+    void (*destructor_cb)(const lv_obj_class_t * class_p, lv_obj_t * obj);
+
+    /** class_p is the class in which event is being processed. */
+    void (*event_cb)(const lv_obj_class_t * class_p, lv_event_t * e);  /**< Widget type specific event function*/
+
+#if LV_USE_OBJ_PROPERTY
+    uint32_t prop_index_start;
+    uint32_t prop_index_end;
+    const lv_property_ops_t * properties;
+    uint32_t properties_count;
+
+#if LV_USE_OBJ_PROPERTY_NAME
+    /* An array of property ID and name */
+    const lv_property_name_t * property_names;
+    uint32_t names_count;
+#endif
+#endif
+
+    void * user_data;
+    const char * name;
+    int32_t width_def;
+    int32_t height_def;
+    uint32_t editable : 2;             /**< Value from ::lv_obj_class_editable_t*/
+    uint32_t group_def : 2;            /**< Value from ::lv_obj_class_group_def_t*/
+    uint32_t instance_size : 16;
+    uint32_t theme_inheritable : 1;    /**< Value from ::lv_obj_class_theme_inheritable_t*/
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_obj_destruct(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_CLASS_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_draw.c

@@ -0,0 +1,458 @@
+/**
+ * @file lv_obj_draw.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_draw_private.h"
+#include "lv_obj_private.h"
+#include "lv_obj_style.h"
+#include "../display/lv_display.h"
+#include "../indev/lv_indev.h"
+#include "../stdlib/lv_string.h"
+#include "../draw/lv_draw_arc.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static inline lv_opa_t get_layer_opa(const lv_obj_t * obj, lv_part_t part, const lv_draw_dsc_base_t * base_dsc);
+static lv_color_t normal_apply_layer_recolor(const lv_obj_t * obj, lv_part_t part,  const lv_draw_dsc_base_t * base_dsc,
+                                             lv_color_t color);
+static lv_color32_t image_apply_layer_recolor(const lv_obj_t * obj, lv_part_t part,
+                                              const lv_draw_dsc_base_t * base_dsc, lv_color_t color, lv_opa_t opa);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_rect_dsc_t * draw_dsc)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    draw_dsc->base.obj = obj;
+    draw_dsc->base.part = part;
+
+    lv_opa_t opa = get_layer_opa(obj, part, &draw_dsc->base);
+    if(part != LV_PART_MAIN) {
+        if(opa <= LV_OPA_MIN) {
+            draw_dsc->bg_opa = LV_OPA_TRANSP;
+            draw_dsc->bg_image_opa = LV_OPA_TRANSP;
+            draw_dsc->border_opa = LV_OPA_TRANSP;
+            draw_dsc->outline_opa = LV_OPA_TRANSP;
+            draw_dsc->shadow_opa = LV_OPA_TRANSP;
+            LV_PROFILER_DRAW_END;
+            return;
+        }
+    }
+
+    draw_dsc->radius = lv_obj_get_style_radius(obj, part);
+
+    if(draw_dsc->bg_opa != LV_OPA_TRANSP) {
+        draw_dsc->bg_opa = lv_obj_get_style_bg_opa(obj, part);
+        if(draw_dsc->bg_opa > LV_OPA_MIN) {
+            lv_color_t bg_color = lv_obj_get_style_bg_color_filtered(obj, part);
+            draw_dsc->bg_color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, bg_color);
+            const lv_grad_dsc_t * grad = lv_obj_get_style_bg_grad(obj, part);
+            if(grad && grad->dir != LV_GRAD_DIR_NONE) {
+                lv_memcpy(&draw_dsc->bg_grad, grad, sizeof(*grad));
+            }
+            else {
+                draw_dsc->bg_grad.dir = lv_obj_get_style_bg_grad_dir(obj, part);
+                if(draw_dsc->bg_grad.dir != LV_GRAD_DIR_NONE) {
+                    draw_dsc->bg_grad.stops[0].color = draw_dsc->bg_color;
+                    lv_color_t bg_grad_color = lv_obj_get_style_bg_grad_color_filtered(obj, part);
+                    draw_dsc->bg_grad.stops[1].color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, bg_grad_color);
+                    draw_dsc->bg_grad.stops[0].frac = lv_obj_get_style_bg_main_stop(obj, part);
+                    draw_dsc->bg_grad.stops[1].frac = lv_obj_get_style_bg_grad_stop(obj, part);
+                    draw_dsc->bg_grad.stops[0].opa = lv_obj_get_style_bg_main_opa(obj, part);
+                    draw_dsc->bg_grad.stops[1].opa = lv_obj_get_style_bg_grad_opa(obj, part);
+                }
+            }
+        }
+    }
+
+    if(draw_dsc->border_opa != LV_OPA_TRANSP) {
+        draw_dsc->border_width = lv_obj_get_style_border_width(obj, part);
+        if(draw_dsc->border_width) {
+            draw_dsc->border_opa = lv_obj_get_style_border_opa(obj, part);
+            if(draw_dsc->border_opa > LV_OPA_MIN) {
+                draw_dsc->border_side = lv_obj_get_style_border_side(obj, part);
+                lv_color_t border_color = lv_obj_get_style_border_color_filtered(obj, part);
+                draw_dsc->border_color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, border_color);
+            }
+        }
+    }
+
+    if(draw_dsc->outline_opa != LV_OPA_TRANSP) {
+        draw_dsc->outline_width = lv_obj_get_style_outline_width(obj, part);
+        if(draw_dsc->outline_width) {
+            draw_dsc->outline_opa = lv_obj_get_style_outline_opa(obj, part);
+            if(draw_dsc->outline_opa > LV_OPA_MIN) {
+                draw_dsc->outline_pad = lv_obj_get_style_outline_pad(obj, part);
+                lv_color_t outline_color = lv_obj_get_style_outline_color_filtered(obj, part);
+                draw_dsc->outline_color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, outline_color);
+            }
+        }
+    }
+
+    if(draw_dsc->bg_image_opa != LV_OPA_TRANSP) {
+        draw_dsc->bg_image_src = lv_obj_get_style_bg_image_src(obj, part);
+        if(draw_dsc->bg_image_src) {
+            draw_dsc->bg_image_opa = lv_obj_get_style_bg_image_opa(obj, part);
+            if(draw_dsc->bg_image_opa > LV_OPA_MIN) {
+                if(lv_image_src_get_type(draw_dsc->bg_image_src) == LV_IMAGE_SRC_SYMBOL) {
+                    draw_dsc->bg_image_symbol_font = lv_obj_get_style_text_font(obj, part);
+                    lv_color_t text_color = lv_obj_get_style_text_color_filtered(obj, part);
+                    draw_dsc->bg_image_recolor = normal_apply_layer_recolor(obj, part, &draw_dsc->base, text_color);
+                }
+                else {
+                    lv_color_t bg_image_recolor = lv_obj_get_style_bg_image_recolor_filtered(obj, part);
+                    lv_opa_t bg_image_recolor_opa = lv_obj_get_style_bg_image_recolor_opa(obj, part);
+                    lv_color32_t result = image_apply_layer_recolor(obj, part, &draw_dsc->base, bg_image_recolor, bg_image_recolor_opa);
+                    draw_dsc->bg_image_recolor_opa = result.alpha;
+                    draw_dsc->bg_image_recolor = lv_color_make(result.red, result.green, result.blue);
+                    draw_dsc->bg_image_tiled = lv_obj_get_style_bg_image_tiled(obj, part);
+                }
+
+                draw_dsc->bg_image_colorkey = lv_obj_get_style_image_colorkey(obj, part);
+            }
+        }
+    }
+
+    if(draw_dsc->shadow_opa) {
+        draw_dsc->shadow_width = lv_obj_get_style_shadow_width(obj, part);
+        if(draw_dsc->shadow_width) {
+            if(draw_dsc->shadow_opa > LV_OPA_MIN) {
+                draw_dsc->shadow_opa = lv_obj_get_style_shadow_opa(obj, part);
+                if(draw_dsc->shadow_opa > LV_OPA_MIN) {
+                    draw_dsc->shadow_offset_x = lv_obj_get_style_shadow_offset_x(obj, part);
+                    draw_dsc->shadow_offset_y = lv_obj_get_style_shadow_offset_y(obj, part);
+                    draw_dsc->shadow_spread = lv_obj_get_style_shadow_spread(obj, part);
+                    lv_color_t shadow_color = lv_obj_get_style_shadow_color_filtered(obj, part);
+                    draw_dsc->shadow_color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, shadow_color);
+                }
+            }
+        }
+    }
+
+    if(opa < LV_OPA_MAX) {
+        draw_dsc->bg_opa = LV_OPA_MIX2(draw_dsc->bg_opa, opa);
+        draw_dsc->bg_image_opa = LV_OPA_MIX2(draw_dsc->bg_image_opa, opa);
+        draw_dsc->border_opa = LV_OPA_MIX2(draw_dsc->border_opa, opa);
+        draw_dsc->shadow_opa = LV_OPA_MIX2(draw_dsc->shadow_opa, opa);
+        draw_dsc->outline_opa = LV_OPA_MIX2(draw_dsc->outline_opa, opa);
+    }
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_obj_init_draw_label_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_label_dsc_t * draw_dsc)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    draw_dsc->base.obj = obj;
+    draw_dsc->base.part = part;
+
+    draw_dsc->opa = lv_obj_get_style_text_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_opa_t opa = get_layer_opa(obj, part, &draw_dsc->base);
+    if(opa < LV_OPA_MAX) {
+        draw_dsc->opa = LV_OPA_MIX2(draw_dsc->opa, opa);
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_color_t text_color = lv_obj_get_style_text_color_filtered(obj, part);
+    draw_dsc->color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, text_color);
+    draw_dsc->letter_space = lv_obj_get_style_text_letter_space(obj, part);
+    draw_dsc->line_space = lv_obj_get_style_text_line_space(obj, part);
+    draw_dsc->decor = lv_obj_get_style_text_decor(obj, part);
+
+    draw_dsc->font = lv_obj_get_style_text_font(obj, part);
+
+#if LV_USE_BIDI
+    draw_dsc->bidi_dir = lv_obj_get_style_base_dir(obj, LV_PART_MAIN);
+#endif
+
+    draw_dsc->align = lv_obj_get_style_text_align(obj, part);
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_obj_init_draw_image_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_image_dsc_t * draw_dsc)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    draw_dsc->base.obj = obj;
+    draw_dsc->base.part = part;
+
+    draw_dsc->opa = lv_obj_get_style_image_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_opa_t opa = get_layer_opa(obj, part, &draw_dsc->base);
+    if(opa < LV_OPA_MAX) {
+        draw_dsc->opa = LV_OPA_MIX2(draw_dsc->opa, opa);
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    draw_dsc->rotation = 0;
+    draw_dsc->scale_x = LV_SCALE_NONE;
+    draw_dsc->scale_y = LV_SCALE_NONE;
+    draw_dsc->pivot.x = lv_area_get_width(&obj->coords) / 2;
+    draw_dsc->pivot.y = lv_area_get_height(&obj->coords) / 2;
+
+    lv_color_t recolor = lv_obj_get_style_image_recolor_filtered(obj, part);
+    lv_opa_t recolor_opa = lv_obj_get_style_image_recolor_opa(obj, part);
+    lv_color32_t result = image_apply_layer_recolor(obj, part, &draw_dsc->base, recolor, recolor_opa);
+    draw_dsc->recolor_opa = result.alpha;
+    draw_dsc->recolor = lv_color_make(result.red, result.green, result.blue);
+
+    draw_dsc->colorkey = lv_obj_get_style_image_colorkey(obj, part);
+
+    if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part);
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_obj_init_draw_line_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_line_dsc_t * draw_dsc)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    draw_dsc->base.obj = obj;
+    draw_dsc->base.part = part;
+
+    draw_dsc->opa = lv_obj_get_style_line_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_opa_t opa = get_layer_opa(obj, part, &draw_dsc->base);
+    if(opa < LV_OPA_MAX) {
+        draw_dsc->opa = LV_OPA_MIX2(draw_dsc->opa, opa);
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    draw_dsc->width = lv_obj_get_style_line_width(obj, part);
+    if(draw_dsc->width == 0) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_color_t line_color = lv_obj_get_style_line_color_filtered(obj, part);
+    draw_dsc->color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, line_color);
+
+    draw_dsc->dash_width = lv_obj_get_style_line_dash_width(obj, part);
+    if(draw_dsc->dash_width) {
+        draw_dsc->dash_gap = lv_obj_get_style_line_dash_gap(obj, part);
+    }
+
+    draw_dsc->round_start = lv_obj_get_style_line_rounded(obj, part);
+    draw_dsc->round_end = draw_dsc->round_start;
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_arc_dsc_t * draw_dsc)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    draw_dsc->base.obj = obj;
+    draw_dsc->base.part = part;
+
+    draw_dsc->width = lv_obj_get_style_arc_width(obj, part);
+    if(draw_dsc->width == 0) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    draw_dsc->opa = lv_obj_get_style_arc_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_opa_t opa = get_layer_opa(obj, part, &draw_dsc->base);
+    if(opa < LV_OPA_MAX) {
+        draw_dsc->opa = LV_OPA_MIX2(draw_dsc->opa, opa);
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_color_t arc_color = lv_obj_get_style_arc_color_filtered(obj, part);
+    draw_dsc->color = normal_apply_layer_recolor(obj, part, &draw_dsc->base, arc_color);
+    draw_dsc->img_src = lv_obj_get_style_arc_image_src(obj, part);
+
+    draw_dsc->rounded = lv_obj_get_style_arc_rounded(obj, part);
+    LV_PROFILER_DRAW_END;
+}
+
+int32_t lv_obj_calculate_ext_draw_size(lv_obj_t * obj, lv_part_t part)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    int32_t s = 0;
+
+    int32_t sh_width = lv_obj_get_style_shadow_width(obj, part);
+    if(sh_width) {
+        lv_opa_t sh_opa = lv_obj_get_style_shadow_opa(obj, part);
+        if(sh_opa > LV_OPA_MIN) {
+            sh_width = sh_width / 2 + 1;    /*The blur adds only half width*/
+            sh_width += lv_obj_get_style_shadow_spread(obj, part);
+            int32_t sh_ofs_x = lv_obj_get_style_shadow_offset_x(obj, part);
+            int32_t sh_ofs_y = lv_obj_get_style_shadow_offset_y(obj, part);
+            sh_width += LV_MAX(LV_ABS(sh_ofs_x), LV_ABS(sh_ofs_y));
+            s = LV_MAX(s, sh_width);
+        }
+    }
+
+    int32_t outline_width = lv_obj_get_style_outline_width(obj, part);
+    if(outline_width) {
+        lv_opa_t outline_opa = lv_obj_get_style_outline_opa(obj, part);
+        if(outline_opa > LV_OPA_MIN) {
+            int32_t outline_pad = lv_obj_get_style_outline_pad(obj, part);
+            s = LV_MAX(s, outline_pad + outline_width);
+        }
+    }
+
+    int32_t w = lv_obj_get_style_transform_width(obj, part);
+    int32_t h = lv_obj_get_style_transform_height(obj, part);
+    int32_t wh = LV_MAX(w, h);
+    if(wh > 0) s += wh;
+
+    LV_PROFILER_DRAW_END;
+    return s;
+}
+
+void lv_obj_refresh_ext_draw_size(lv_obj_t * obj)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t s_old = lv_obj_get_ext_draw_size(obj);
+    int32_t s_new = 0;
+    lv_obj_send_event(obj, LV_EVENT_REFR_EXT_DRAW_SIZE, &s_new);
+
+    /*Store the result if the special attrs already allocated*/
+    if(obj->spec_attr) {
+        obj->spec_attr->ext_draw_size = s_new;
+    }
+    /*Allocate spec. attrs. only if the result is not zero.
+     *Zero is the default value if the spec. attr. are not defined.*/
+    else if(s_new != 0) {
+        lv_obj_allocate_spec_attr(obj);
+        obj->spec_attr->ext_draw_size = s_new;
+    }
+
+    if(s_new != s_old) lv_obj_invalidate(obj);
+    LV_PROFILER_DRAW_END;
+}
+
+int32_t lv_obj_get_ext_draw_size(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->ext_draw_size;
+    else return 0;
+}
+
+lv_layer_type_t lv_obj_get_layer_type(const lv_obj_t * obj)
+{
+
+    if(obj->spec_attr) return (lv_layer_type_t)obj->spec_attr->layer_type;
+    else return LV_LAYER_TYPE_NONE;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static inline lv_opa_t get_layer_opa(const lv_obj_t * obj, lv_part_t part, const lv_draw_dsc_base_t * base_dsc)
+{
+    if(base_dsc->layer) {
+        /* Accessing the layer opa directly is faster than using get style opa recursive */
+        if(part == LV_PART_MAIN) {
+            return base_dsc->layer->opa;
+        }
+
+        return LV_OPA_MIX2(base_dsc->layer->opa, lv_obj_get_style_opa(obj, part));
+    }
+
+    /* fallback to old recursive style opa */
+    return lv_obj_get_style_opa_recursive(obj, part);
+}
+
+
+static lv_color_t normal_apply_layer_recolor(const lv_obj_t * obj, lv_part_t part,  const lv_draw_dsc_base_t * base_dsc,
+                                             lv_color_t color)
+{
+    lv_color32_t recolor;
+
+    if(base_dsc->layer) {
+        recolor = base_dsc->layer->recolor;
+        if(part != LV_PART_MAIN) {
+            recolor = lv_obj_style_apply_recolor(obj, part, recolor);
+        }
+    }
+    else {
+        recolor = lv_obj_get_style_recolor_recursive(obj, part);
+    }
+
+    return lv_color_mix(lv_color_make(recolor.red, recolor.green, recolor.blue), color, recolor.alpha);
+}
+
+
+static lv_color32_t image_apply_layer_recolor(const lv_obj_t * obj, lv_part_t part,
+                                              const lv_draw_dsc_base_t * base_dsc, lv_color_t color, lv_opa_t opa)
+{
+    lv_color32_t recolor;
+
+    if(base_dsc->layer) {
+        recolor = base_dsc->layer->recolor;
+        if(part != LV_PART_MAIN) {
+            recolor = lv_obj_style_apply_recolor(obj, part, recolor);
+        }
+    }
+    else {
+        recolor = lv_obj_get_style_recolor_recursive(obj, part);
+    }
+
+    if(opa > LV_OPA_TRANSP && recolor.alpha > LV_OPA_TRANSP) {
+        return lv_color_over32(recolor, lv_color_to_32(color, opa));
+    }
+    else if(recolor.alpha > LV_OPA_TRANSP) {
+        return recolor;
+    }
+    else {
+        return lv_color_to_32(color, opa);
+    }
+}

components/easylvgl/lvgl9/src/core/lv_obj_draw.h

@@ -0,0 +1,129 @@
+/**
+ * @file lv_obj_draw.h
+ *
+ */
+
+#ifndef LV_OBJ_DRAW_H
+#define LV_OBJ_DRAW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../draw/lv_draw_rect.h"
+#include "../draw/lv_draw_label.h"
+#include "../draw/lv_draw_image.h"
+#include "../draw/lv_draw_line.h"
+#include "../draw/lv_draw_arc.h"
+#include "../draw/lv_draw_triangle.h"
+#include "lv_obj_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/** Store the type of layer required to render a widget.*/
+typedef enum {
+    /**No layer is needed. */
+    LV_LAYER_TYPE_NONE,
+
+    /**Simple layer means that the layer can be rendered in chunks.
+     * For example with opa_layered = 140 it's possible to render only 10 lines
+     * from the layer. When it's ready go to the next 10 lines.
+     * It avoids large memory allocations for the layer buffer.
+     * The buffer size for a chunk can be set by `LV_DRAW_LAYER_SIMPLE_BUF_SIZE` in lv_conf.h.*/
+    LV_LAYER_TYPE_SIMPLE,
+
+    /**The widget is transformed and cannot be rendered in chunks.
+     * It's because - due to the transformations -  pixel outside of
+     * a given area will also contribute to the final image.
+     * In this case there is no limitation on the buffer size.
+     * LVGL will allocate as large buffer as needed to render the transformed area.*/
+    LV_LAYER_TYPE_TRANSFORM,
+} lv_layer_type_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a rectangle draw descriptor from an object's styles in its current state
+ * @param obj       pointer to an object
+ * @param part      part of the object, e.g. `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
+ * @param draw_dsc  the descriptor to initialize.
+ *                  If an `..._opa` field is set to `LV_OPA_TRANSP` the related properties won't be initialized.
+ *                  Should be initialized with `lv_draw_rect_dsc_init(draw_dsc)`.
+ * @note Only the relevant fields will be set.
+ *       E.g. if `border width == 0` the other border properties won't be evaluated.
+ */
+void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_rect_dsc_t * draw_dsc);
+
+/**
+ * Initialize a label draw descriptor from an object's styles in its current state
+ * @param obj       pointer to an object
+ * @param part      part of the object, e.g. `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
+ * @param draw_dsc  the descriptor to initialize.
+ *                  If the `opa` field is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                  Should be initialized with `lv_draw_label_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_label_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_label_dsc_t * draw_dsc);
+
+/**
+ * Initialize an image draw descriptor from an object's styles in its current state
+ * @param obj       pointer to an object
+ * @param part      part of the object, e.g. `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
+ * @param draw_dsc  the descriptor to initialize.
+ *                  Should be initialized with `lv_draw_image_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_image_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_image_dsc_t * draw_dsc);
+
+/**
+ * Initialize a line draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param part      part of the object, e.g. `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
+ * @param draw_dsc  the descriptor to initialize.
+ *                  Should be initialized with `lv_draw_line_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_line_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_line_dsc_t * draw_dsc);
+
+/**
+ * Initialize an arc draw descriptor from an object's styles in its current state
+ * @param obj       pointer to an object
+ * @param part      part of the object, e.g. `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
+ * @param draw_dsc  the descriptor to initialize.
+ *                  Should be initialized with `lv_draw_arc_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_arc_dsc_t * draw_dsc);
+
+/**
+ * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
+ * @param obj       pointer to an object
+ * @param part      part of the object
+ * @return          the extra size required around the object
+ */
+int32_t lv_obj_calculate_ext_draw_size(lv_obj_t * obj, lv_part_t part);
+
+/**
+ * Send a 'LV_EVENT_REFR_EXT_DRAW_SIZE' Call the ancestor's event handler to the object to refresh the value of the extended draw size.
+ * The result will be saved in `obj`.
+ * @param obj       pointer to an object
+ */
+void lv_obj_refresh_ext_draw_size(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_DRAW_H*/

components/easylvgl/lvgl9/src/core/lv_obj_draw_private.h

@@ -0,0 +1,48 @@
+/**
+ * @file lv_obj_draw_private.h
+ *
+ */
+
+#ifndef LV_OBJ_DRAW_PRIVATE_H
+#define LV_OBJ_DRAW_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Get the extended draw area of an object.
+ * @param obj       pointer to an object
+ * @return          the size extended draw area around the real coordinates
+ */
+int32_t lv_obj_get_ext_draw_size(const lv_obj_t * obj);
+
+lv_layer_type_t lv_obj_get_layer_type(const lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_DRAW_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_event.c

@@ -0,0 +1,480 @@
+/**
+ * @file lv_obj_event.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_event_private.h"
+#include "lv_obj_event_private.h"
+#include "lv_obj_class_private.h"
+#include "lv_obj_private.h"
+#include "../indev/lv_indev.h"
+#include "../indev/lv_indev_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_result_t event_send_core(lv_event_t * e);
+static bool event_is_bubbled(lv_event_t * e);
+static bool event_is_trickled(lv_event_t * e);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#if LV_USE_LOG && LV_LOG_TRACE_EVENT
+    #define LV_TRACE_EVENT(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+    #define LV_TRACE_EVENT(...)
+#endif
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * param)
+{
+    if(obj == NULL) return LV_RESULT_OK;
+
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_event_t e;
+    e.current_target = obj;
+    e.original_target = obj;
+    e.code = event_code;
+    e.user_data = NULL;
+    e.param = param;
+    e.deleted = 0;
+    e.stop_bubbling = 0;
+    e.stop_processing = 0;
+    e.stop_trickling = 0;
+
+    lv_event_push(&e);
+
+    /*Send the event*/
+    lv_result_t res = event_send_core(&e);
+
+    /*Remove this element from the list*/
+    lv_event_pop(&e);
+
+    return res;
+}
+
+lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
+{
+    const lv_obj_class_t * base;
+    if(class_p == NULL) base = ((lv_obj_t *)e->current_target)->class_p;
+    else base = class_p->base_class;
+
+    /*Find a base in which call the ancestor's event handler_cb if set*/
+    while(base && base->event_cb == NULL) base = base->base_class;
+
+    if(base == NULL) return LV_RESULT_OK;
+    if(base->event_cb == NULL) return LV_RESULT_OK;
+
+    /*Call the actual event callback*/
+    e->user_data = NULL;
+    LV_PROFILER_EVENT_BEGIN_TAG(lv_event_code_get_name(e->code));
+    base->event_cb(base, e);
+    LV_PROFILER_EVENT_END_TAG(lv_event_code_get_name(e->code));
+
+    lv_result_t res = LV_RESULT_OK;
+    /*Stop if the object is deleted*/
+    if(e->deleted) res = LV_RESULT_INVALID;
+
+    return res;
+}
+
+lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_obj_allocate_spec_attr(obj);
+
+    return lv_event_add(&obj->spec_attr->event_list, event_cb, filter, user_data);
+}
+
+uint32_t lv_obj_get_event_count(lv_obj_t * obj)
+{
+    LV_ASSERT_NULL(obj);
+    if(obj->spec_attr == NULL) return 0;
+    return lv_event_get_count(&obj->spec_attr->event_list);
+}
+
+lv_event_dsc_t * lv_obj_get_event_dsc(lv_obj_t * obj, uint32_t index)
+{
+    LV_ASSERT_NULL(obj);
+    if(obj->spec_attr == NULL) return NULL;
+    return lv_event_get_dsc(&obj->spec_attr->event_list, index);
+}
+
+bool lv_obj_remove_event(lv_obj_t * obj, uint32_t index)
+{
+    LV_ASSERT_NULL(obj);
+    if(obj->spec_attr == NULL) return false;
+    return lv_event_remove(&obj->spec_attr->event_list, index);
+}
+
+bool lv_obj_remove_event_dsc(lv_obj_t * obj, lv_event_dsc_t * dsc)
+{
+    LV_ASSERT_NULL(obj);
+    LV_ASSERT_NULL(dsc);
+    if(obj->spec_attr == NULL) return false;
+    return lv_event_remove_dsc(&obj->spec_attr->event_list, dsc);
+}
+
+uint32_t lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
+{
+    LV_ASSERT_NULL(obj);
+
+    uint32_t event_cnt = lv_obj_get_event_count(obj);
+    uint32_t removed_count = 0;
+    int32_t i;
+
+    if(event_cnt == 0) return 0;
+
+    for(i = event_cnt - 1; i >= 0; i--) {
+        lv_event_dsc_t * dsc = lv_obj_get_event_dsc(obj, i);
+        if(dsc && dsc->cb == event_cb) {
+            lv_obj_remove_event(obj, i);
+            removed_count++;
+        }
+    }
+
+    return removed_count;
+}
+
+uint32_t lv_obj_remove_event_cb_with_user_data(lv_obj_t * obj, lv_event_cb_t event_cb, void * user_data)
+{
+    LV_ASSERT_NULL(obj);
+
+    uint32_t event_cnt = lv_obj_get_event_count(obj);
+    uint32_t removed_count = 0;
+    int32_t i;
+
+    if(event_cnt == 0) return 0;
+
+    for(i = event_cnt - 1; i >= 0; i--) {
+        lv_event_dsc_t * dsc = lv_obj_get_event_dsc(obj, i);
+        if(dsc && (event_cb == NULL || dsc->cb == event_cb) && dsc->user_data == user_data) {
+            lv_obj_remove_event(obj, i);
+            removed_count ++;
+        }
+    }
+
+    return removed_count;
+}
+
+lv_obj_t * lv_event_get_current_target_obj(lv_event_t * e)
+{
+    return lv_event_get_current_target(e);
+}
+
+lv_obj_t * lv_event_get_target_obj(lv_event_t * e)
+{
+    return lv_event_get_target(e);
+}
+
+lv_indev_t * lv_event_get_indev(lv_event_t * e)
+{
+
+    if(e->code == LV_EVENT_PRESSED ||
+       e->code == LV_EVENT_PRESSING ||
+       e->code == LV_EVENT_PRESS_LOST ||
+       e->code == LV_EVENT_SHORT_CLICKED ||
+       e->code == LV_EVENT_LONG_PRESSED ||
+       e->code == LV_EVENT_LONG_PRESSED_REPEAT ||
+       e->code == LV_EVENT_CLICKED ||
+       e->code == LV_EVENT_RELEASED ||
+       e->code == LV_EVENT_SCROLL_BEGIN ||
+       e->code == LV_EVENT_SCROLL_END ||
+       e->code == LV_EVENT_SCROLL ||
+       e->code == LV_EVENT_GESTURE ||
+       e->code == LV_EVENT_KEY ||
+       e->code == LV_EVENT_FOCUSED ||
+       e->code == LV_EVENT_DEFOCUSED ||
+       e->code == LV_EVENT_LEAVE ||
+       e->code == LV_EVENT_HOVER_OVER ||
+       e->code == LV_EVENT_HOVER_LEAVE) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+lv_layer_t * lv_event_get_layer(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_DRAW_MAIN ||
+       e->code == LV_EVENT_DRAW_MAIN_BEGIN ||
+       e->code == LV_EVENT_DRAW_MAIN_END ||
+       e->code == LV_EVENT_DRAW_POST ||
+       e->code == LV_EVENT_DRAW_POST_BEGIN ||
+       e->code == LV_EVENT_DRAW_POST_END) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+const lv_area_t * lv_event_get_old_size(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_SIZE_CHANGED) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+uint32_t lv_event_get_key(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_KEY) {
+        uint32_t * k = lv_event_get_param(e);
+        if(k) return *k;
+        else return 0;
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return 0;
+    }
+}
+
+int32_t lv_event_get_rotary_diff(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_ROTARY) {
+        int32_t * r = lv_event_get_param(e);
+        if(r) return *r;
+        else return 0;
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return 0;
+    }
+}
+
+lv_anim_t * lv_event_get_scroll_anim(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_SCROLL_BEGIN) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+void lv_event_set_ext_draw_size(lv_event_t * e, int32_t size)
+{
+    if(e->code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
+        int32_t * cur_size = lv_event_get_param(e);
+        *cur_size = LV_MAX(*cur_size, size);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+    }
+}
+
+lv_point_t * lv_event_get_self_size_info(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_GET_SELF_SIZE) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return 0;
+    }
+}
+
+lv_hit_test_info_t * lv_event_get_hit_test_info(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_HIT_TEST) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return 0;
+    }
+}
+
+const lv_area_t * lv_event_get_cover_area(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_COVER_CHECK) {
+        lv_cover_check_info_t * p = lv_event_get_param(e);
+        return p->area;
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+void lv_event_set_cover_res(lv_event_t * e, lv_cover_res_t res)
+{
+    if(e->code == LV_EVENT_COVER_CHECK) {
+        lv_cover_check_info_t * p = lv_event_get_param(e);
+        if(res > p->res) p->res = res;  /*Save only "stronger" results*/
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+    }
+}
+
+lv_draw_task_t * lv_event_get_draw_task(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_DRAW_TASK_ADDED) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_result_t event_send_core(lv_event_t * e)
+{
+    LV_TRACE_EVENT("Sending event %d to %p with %p param", e->code, (void *)e->original_target, e->param);
+
+    lv_indev_t * indev_act = lv_indev_active();
+    if(indev_act) {
+        if(e->stop_processing) return LV_RESULT_OK;
+        if(e->deleted) return LV_RESULT_INVALID;
+    }
+
+    lv_obj_t * target = e->current_target;
+    lv_result_t res = LV_RESULT_OK;
+    lv_event_list_t * list = target->spec_attr ?  &target->spec_attr->event_list : NULL;
+
+    res = lv_event_send(list, e, true);
+    if(res != LV_RESULT_OK || e->stop_processing) return res;
+
+    res = lv_obj_event_base(NULL, e);
+    if(res != LV_RESULT_OK || e->stop_processing) return res;
+
+    res = lv_event_send(list, e, false);
+    if(res != LV_RESULT_OK || e->stop_processing) return res;
+
+    lv_obj_t * parent = lv_obj_get_parent(e->current_target);
+    if(parent && event_is_bubbled(e)) {
+        e->current_target = parent;
+        res = event_send_core(e);
+    }
+    if(res != LV_RESULT_OK) return res;
+
+    /*Trickle down to children if enabled*/
+    if(event_is_trickled(e)) {
+        uint32_t child_count = lv_obj_get_child_count(target);
+
+        /* we don't want the event to bubble up again when trickling down */
+        e->stop_bubbling = 1;
+
+        for(uint32_t i = 0; i < child_count && res == LV_RESULT_OK && !e->stop_processing; i++) {
+            lv_obj_t * child = lv_obj_get_child(target, i);
+            if(child) {
+                e->current_target = child;
+                res = event_send_core(e);
+                if(res != LV_RESULT_OK) {
+                    LV_LOG_WARN("Trickle down event %d to child %p failed", e->code, (void *)child);
+                    break;
+                }
+            }
+        }
+    }
+
+    return res;
+}
+
+static bool event_is_bubbled(lv_event_t * e)
+{
+    if(e->stop_bubbling) return false;
+
+    /*Event codes that always bubble*/
+    switch(e->code) {
+        case LV_EVENT_CHILD_CREATED:
+        case LV_EVENT_CHILD_DELETED:
+            return true;
+        default:
+            break;
+    }
+
+    /*Check other codes only if bubbling is enabled*/
+    if(lv_obj_has_flag(e->current_target, LV_OBJ_FLAG_EVENT_BUBBLE) == false) return false;
+
+    switch(e->code) {
+        case LV_EVENT_HIT_TEST:
+        case LV_EVENT_COVER_CHECK:
+        case LV_EVENT_REFR_EXT_DRAW_SIZE:
+        case LV_EVENT_DRAW_MAIN_BEGIN:
+        case LV_EVENT_DRAW_MAIN:
+        case LV_EVENT_DRAW_MAIN_END:
+        case LV_EVENT_DRAW_POST_BEGIN:
+        case LV_EVENT_DRAW_POST:
+        case LV_EVENT_DRAW_POST_END:
+        case LV_EVENT_DRAW_TASK_ADDED:
+        case LV_EVENT_REFRESH:
+        case LV_EVENT_DELETE:
+        case LV_EVENT_CHILD_CREATED:
+        case LV_EVENT_CHILD_DELETED:
+        case LV_EVENT_CHILD_CHANGED:
+        case LV_EVENT_SIZE_CHANGED:
+        case LV_EVENT_STYLE_CHANGED:
+        case LV_EVENT_GET_SELF_SIZE:
+            return false;
+        default:
+            return true;
+    }
+}
+
+static bool event_is_trickled(lv_event_t * e)
+{
+    if(e->stop_trickling) return false;
+
+    /*Check other codes only if trickle is enabled*/
+    if(lv_obj_has_flag(e->current_target, LV_OBJ_FLAG_EVENT_TRICKLE) == false) return false;
+
+    switch(e->code) {
+        case LV_EVENT_HIT_TEST:
+        case LV_EVENT_COVER_CHECK:
+        case LV_EVENT_REFR_EXT_DRAW_SIZE:
+        case LV_EVENT_DRAW_MAIN_BEGIN:
+        case LV_EVENT_DRAW_MAIN:
+        case LV_EVENT_DRAW_MAIN_END:
+        case LV_EVENT_DRAW_POST_BEGIN:
+        case LV_EVENT_DRAW_POST:
+        case LV_EVENT_DRAW_POST_END:
+        case LV_EVENT_DRAW_TASK_ADDED:
+        case LV_EVENT_REFRESH:
+        case LV_EVENT_DELETE:
+        case LV_EVENT_CHILD_CREATED:
+        case LV_EVENT_CHILD_DELETED:
+        case LV_EVENT_CHILD_CHANGED:
+        case LV_EVENT_SIZE_CHANGED:
+        case LV_EVENT_STYLE_CHANGED:
+        case LV_EVENT_GET_SELF_SIZE:
+            return false;
+        default:
+            return true;
+    }
+}

components/easylvgl/lvgl9/src/core/lv_obj_event.h

@@ -0,0 +1,204 @@
+/**
+ * @file lv_obj_event.h
+ *
+ */
+
+#ifndef LV_OBJ_EVENT_H
+#define LV_OBJ_EVENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_event.h"
+#include "../indev/lv_indev.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/** Cover check results.*/
+typedef enum {
+    LV_COVER_RES_COVER      = 0,
+    LV_COVER_RES_NOT_COVER  = 1,
+    LV_COVER_RES_MASKED     = 2,
+} lv_cover_res_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Send an event to the object
+ * @param obj           pointer to an object
+ * @param event_code    the type of the event from `lv_event_t`
+ * @param param         arbitrary data depending on the widget type and the event. (Usually `NULL`)
+ * @return LV_RESULT_OK: `obj` was not deleted in the event; LV_RESULT_INVALID: `obj` was deleted in the event_code
+ */
+lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * param);
+
+/**
+ * Used by the widgets internally to call the ancestor widget types's event handler
+ * @param class_p   pointer to the class of the widget (NOT the ancestor class)
+ * @param e         pointer to the event descriptor
+ * @return          LV_RESULT_OK: the target object was not deleted in the event; LV_RESULT_INVALID: it was deleted in the event_code
+ */
+lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e);
+
+/**
+ * Get the current target of the event. It's the object which event handler being called.
+ * If the event is not bubbled it's the same as "original" target.
+ * @param e     pointer to the event descriptor
+ * @return      the target of the event_code
+ */
+lv_obj_t * lv_event_get_current_target_obj(lv_event_t * e);
+
+/**
+ * Get the object originally targeted by the event. It's the same even if the event is bubbled.
+ * @param e     pointer to the event descriptor
+ * @return      pointer to the original target of the event_code
+ */
+lv_obj_t * lv_event_get_target_obj(lv_event_t * e);
+
+/**
+ * Add an event handler function for an object.
+ * Used by the user to react on event which happens with the object.
+ * An object can have multiple event handler. They will be called in the same order as they were added.
+ * @param obj       pointer to an object
+ * @param filter    an event code (e.g. `LV_EVENT_CLICKED`) on which the event should be called. `LV_EVENT_ALL` can be used to receive all the events.
+ * @param event_cb  the new event function
+ * @param           user_data custom data will be available in `event_cb`
+ * @return          handler to the event. It can be used in `lv_obj_remove_event_dsc`.
+ */
+lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data);
+
+uint32_t lv_obj_get_event_count(lv_obj_t * obj);
+
+lv_event_dsc_t * lv_obj_get_event_dsc(lv_obj_t * obj, uint32_t index);
+
+bool lv_obj_remove_event(lv_obj_t * obj, uint32_t index);
+
+bool lv_obj_remove_event_dsc(lv_obj_t * obj, lv_event_dsc_t * dsc);
+
+/**
+ * Remove an event_cb from an object
+ * @param obj           pointer to a obj
+ * @param event_cb      the event_cb of the event to remove
+ * @return              the count of the event removed
+ */
+uint32_t lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb);
+
+/**
+ * Remove an event_cb with user_data
+ * @param obj           pointer to a obj
+ * @param event_cb      the event_cb of the event to remove
+ * @param user_data     user_data
+ * @return              the count of the event removed
+ */
+uint32_t lv_obj_remove_event_cb_with_user_data(lv_obj_t * obj, lv_event_cb_t event_cb, void * user_data);
+
+/**
+ * Get the input device passed as parameter to indev related events.
+ * @param e     pointer to an event
+ * @return      the indev that triggered the event or NULL if called on a not indev related event
+ */
+lv_indev_t * lv_event_get_indev(lv_event_t * e);
+
+/**
+ * Get the draw context which should be the first parameter of the draw functions.
+ * Namely: `LV_EVENT_DRAW_MAIN/POST`, `LV_EVENT_DRAW_MAIN/POST_BEGIN`, `LV_EVENT_DRAW_MAIN/POST_END`
+ * @param e     pointer to an event
+ * @return      pointer to a draw context or NULL if called on an unrelated event
+ */
+lv_layer_t * lv_event_get_layer(lv_event_t * e);
+
+/**
+ * Get the old area of the object before its size was changed. Can be used in `LV_EVENT_SIZE_CHANGED`
+ * @param e     pointer to an event
+ * @return      the old absolute area of the object or NULL if called on an unrelated event
+ */
+const lv_area_t * lv_event_get_old_size(lv_event_t * e);
+
+/**
+ * Get the key passed as parameter to an event. Can be used in `LV_EVENT_KEY`
+ * @param e     pointer to an event
+ * @return      the triggering key or NULL if called on an unrelated event
+ */
+uint32_t lv_event_get_key(lv_event_t * e);
+
+/**
+ * Get the signed rotary encoder diff. passed as parameter to an event. Can be used in `LV_EVENT_ROTARY`
+ * @param e     pointer to an event
+ * @return      the triggering key or NULL if called on an unrelated event
+ */
+int32_t lv_event_get_rotary_diff(lv_event_t * e);
+
+/**
+ * Get the animation descriptor of a scrolling. Can be used in `LV_EVENT_SCROLL_BEGIN`
+ * @param e     pointer to an event
+ * @return      the animation that will scroll the object. (can be modified as required)
+ */
+lv_anim_t * lv_event_get_scroll_anim(lv_event_t * e);
+
+/**
+ * Set the new extra draw size. Can be used in `LV_EVENT_REFR_EXT_DRAW_SIZE`
+ * @param e     pointer to an event
+ * @param size  The new extra draw size
+ */
+void lv_event_set_ext_draw_size(lv_event_t * e, int32_t size);
+
+/**
+ * Get a pointer to an `lv_point_t` variable in which the self size should be saved (width in `point->x` and height `point->y`).
+ * Can be used in `LV_EVENT_GET_SELF_SIZE`
+ * @param e     pointer to an event
+ * @return      pointer to `lv_point_t` or NULL if called on an unrelated event
+ */
+lv_point_t * lv_event_get_self_size_info(lv_event_t * e);
+
+/**
+ * Get a pointer to an `lv_hit_test_info_t` variable in which the hit test result should be saved. Can be used in `LV_EVENT_HIT_TEST`
+ * @param e     pointer to an event
+ * @return      pointer to `lv_hit_test_info_t` or NULL if called on an unrelated event
+ */
+lv_hit_test_info_t * lv_event_get_hit_test_info(lv_event_t * e);
+
+/**
+ * Get a pointer to an area which should be examined whether the object fully covers it or not.
+ * Can be used in `LV_EVENT_HIT_TEST`
+ * @param e     pointer to an event
+ * @return      an area with absolute coordinates to check
+ */
+const lv_area_t * lv_event_get_cover_area(lv_event_t * e);
+
+/**
+ * Set the result of cover checking. Can be used in `LV_EVENT_COVER_CHECK`
+ * @param e     pointer to an event
+ * @param res   an element of ::lv_cover_check_info_t
+ */
+void lv_event_set_cover_res(lv_event_t * e, lv_cover_res_t res);
+
+/**
+ * Get the draw task which was just added.
+ * Can be used in `LV_EVENT_DRAW_TASK_ADDED event`
+ * @param e     pointer to an event
+ * @return      the added draw task
+ */
+lv_draw_task_t * lv_event_get_draw_task(lv_event_t * e);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_EVENT_H*/

components/easylvgl/lvgl9/src/core/lv_obj_event_private.h

@@ -0,0 +1,62 @@
+/**
+ * @file lv_obj_event_private.h
+ *
+ */
+
+#ifndef LV_OBJ_EVENT_PRIVATE_H
+#define LV_OBJ_EVENT_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj_event.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Used as the event parameter of ::LV_EVENT_HIT_TEST to check if an `point` can click the object or not.
+ * `res` should be set like this:
+ *   - If already set to `false` another event wants that point non clickable. If you want to respect it leave it as `false` or set `true` to overwrite it.
+ *   - If already set `true` and `point` shouldn't be clickable set to `false`
+ *   - If already set to `true` you agree that `point` can click the object leave it as `true`
+ */
+struct _lv_hit_test_info_t {
+    const lv_point_t * point;   /**< A point relative to screen to check if it can click the object or not*/
+    bool res;                   /**< true: `point` can click the object; false: it cannot*/
+};
+
+/**
+ * Used as the event parameter of ::LV_EVENT_COVER_CHECK to check if an area is covered by the object or not.
+ * In the event use `const lv_area_t * area = lv_event_get_cover_area(e)` to get the area to check
+ * and `lv_event_set_cover_res(e, res)` to set the result.
+ */
+struct _lv_cover_check_info_t {
+    lv_cover_res_t res;
+    const lv_area_t * area;
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_EVENT_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_id_builtin.c

@@ -0,0 +1,122 @@
+/**
+ * @file lv_obj_id_builtin.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_class_private.h"
+#include "lv_obj_private.h"
+#include "lv_global.h"
+#include "../osal/lv_os_private.h"
+#include "../stdlib/lv_sprintf.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+typedef struct _class_info_t {
+    const lv_obj_class_t * class_p;
+    uint32_t obj_count;
+} class_info_t;
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+#if LV_USE_OBJ_ID && LV_USE_OBJ_ID_BUILTIN
+
+void lv_obj_assign_id(const lv_obj_class_t * class_p, lv_obj_t * obj)
+{
+    LV_ASSERT(obj && class_p);
+
+    uint32_t i;
+    uint32_t id = 0;
+    lv_global_t * global = LV_GLOBAL_DEFAULT();
+    class_info_t * info = NULL;
+
+    if(obj == NULL || class_p == NULL) return;
+    if(global == NULL) return;
+
+    obj->id = NULL;
+
+    for(i = 0; i < global->objid_count; i ++) {
+        info = ((class_info_t *)global->objid_array) + i;
+        if(class_p == info->class_p) break;
+    }
+
+    /*Resize array*/
+    if(i == global->objid_count) {
+        void * array = lv_realloc(global->objid_array, sizeof(class_info_t) * (global->objid_count + 1));
+        LV_ASSERT_MALLOC(array);
+        if(array == NULL) return;
+        global->objid_array = array;
+        global->objid_count ++;
+        info = ((class_info_t *)global->objid_array) + i;
+        info->obj_count = 0;
+        info->class_p = class_p;
+    }
+
+    id = ++info->obj_count;
+
+    obj->id = (void *)(lv_uintptr_t)id;
+}
+
+void lv_obj_set_id(lv_obj_t * obj, void * id)
+{
+    LV_ASSERT_NULL(obj);
+    if(obj->id) lv_obj_free_id(obj);
+    obj->id = id;
+}
+
+void lv_obj_free_id(lv_obj_t * obj)
+{
+    LV_UNUSED(obj);
+    obj->id = NULL;
+}
+
+const char * lv_obj_stringify_id(lv_obj_t * obj, char * buf, uint32_t len)
+{
+    const char * name;
+    if(obj == NULL || obj->class_p == NULL) return NULL;
+    if(buf == NULL) return NULL;
+
+    name = obj->class_p->name;
+    if(name == NULL) name = "nameless";
+
+    lv_snprintf(buf, len, "%s%" LV_PRIu32 "", name, (uint32_t)(lv_uintptr_t)obj->id);
+    return buf;
+}
+
+void lv_objid_builtin_destroy(void)
+{
+    lv_global_t * global = LV_GLOBAL_DEFAULT();
+    if(global == NULL) return;
+
+    lv_free(global->objid_array);
+    global->objid_count = 0;
+}
+
+int lv_obj_id_compare(const void * id1, const void * id2)
+{
+    return id1 == id2 ? 0 : 1;
+}
+
+#endif /*LV_USE_OBJ_ID_BUILTIN*/

components/easylvgl/lvgl9/src/core/lv_obj_pos.c

@@ -0,0 +1,1318 @@
+/**
+ * @file lv_obj_pos.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_area_private.h"
+#include "../layouts/lv_layout_private.h"
+#include "lv_obj_event_private.h"
+#include "lv_obj_draw_private.h"
+#include "lv_obj_style_private.h"
+#include "lv_obj_private.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "lv_refr_private.h"
+#include "../core/lv_global.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+#define update_layout_mutex LV_GLOBAL_DEFAULT()->layout_update_mutex
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static int32_t calc_content_width(lv_obj_t * obj);
+static int32_t calc_content_height(lv_obj_t * obj);
+static void layout_update_core(lv_obj_t * obj);
+static void transform_point_array(const lv_obj_t * obj, lv_point_t * p, size_t p_count, bool inv);
+static bool is_transformed(const lv_obj_t * obj);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_obj_set_pos(lv_obj_t * obj, int32_t x, int32_t y)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_set_x(obj, x);
+    lv_obj_set_y(obj, y);
+}
+
+void lv_obj_set_x(lv_obj_t * obj, int32_t x)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_style_res_t res_x;
+    lv_style_value_t v_x;
+
+    res_x = lv_obj_get_local_style_prop(obj, LV_STYLE_X, &v_x, 0);
+
+    if((res_x == LV_STYLE_RES_FOUND && v_x.num != x) || res_x == LV_STYLE_RES_NOT_FOUND) {
+        lv_obj_set_style_x(obj, x, 0);
+    }
+}
+
+void lv_obj_set_y(lv_obj_t * obj, int32_t y)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_style_res_t res_y;
+    lv_style_value_t v_y;
+
+    res_y = lv_obj_get_local_style_prop(obj, LV_STYLE_Y, &v_y, 0);
+
+    if((res_y == LV_STYLE_RES_FOUND && v_y.num != y) || res_y == LV_STYLE_RES_NOT_FOUND) {
+        lv_obj_set_style_y(obj, y, 0);
+    }
+}
+
+static int32_t calc_dynamic_width(lv_obj_t * obj, int32_t width, int32_t * const content_width)
+{
+    if(width == LV_SIZE_CONTENT) {
+        if(*content_width < 0) {
+            *content_width = calc_content_width(obj);
+        }
+        width = *content_width;
+    }
+    else if(LV_COORD_IS_PCT(width)) {
+        lv_obj_t * parent = lv_obj_get_parent(obj);
+        if(parent->w_layout == 0 && lv_obj_get_style_width(parent, 0) == LV_SIZE_CONTENT) {
+            /*If parent has content size and the child has pct size
+             *a circular dependency will occur. To solve it keep child size at zero */
+            width = lv_obj_get_style_space_left(obj, 0) + lv_obj_get_style_space_right(obj, 0);
+        }
+        else {
+            int32_t parent_w = lv_obj_get_content_width(parent);
+            width = (LV_COORD_GET_PCT(width) * parent_w) / 100;
+            width -= lv_obj_get_style_margin_left(obj, LV_PART_MAIN) + lv_obj_get_style_margin_right(obj, LV_PART_MAIN);
+        }
+    }
+    return width;
+}
+
+static int32_t calc_dynamic_height(lv_obj_t * obj, int32_t height, int32_t * const content_height)
+{
+    if(height == LV_SIZE_CONTENT) {
+        if(*content_height < 0) {
+            *content_height = calc_content_height(obj);
+        }
+        height = *content_height;
+    }
+    else if(LV_COORD_IS_PCT(height)) {
+        lv_obj_t * parent = lv_obj_get_parent(obj);
+        if(parent->h_layout == 0 && lv_obj_get_style_height(parent, 0) == LV_SIZE_CONTENT) {
+            /*If parent has content size and the child has pct size
+             *a circular dependency will occur. To solve it keep child size at zero */
+            height = lv_obj_get_style_space_top(obj, 0) + lv_obj_get_style_space_bottom(obj, 0);
+        }
+
+        else {
+            int32_t parent_h = lv_obj_get_content_height(parent);
+            height = (LV_COORD_GET_PCT(height) * parent_h) / 100;
+            height -=
+                lv_obj_get_style_margin_top(obj, LV_PART_MAIN) + lv_obj_get_style_margin_bottom(obj, LV_PART_MAIN);
+        }
+    }
+    return height;
+}
+
+bool lv_obj_refr_size(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    /*If the width or height is set by a layout do not modify them*/
+    if(obj->w_layout && obj->h_layout) return false;
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent == NULL) return false;
+
+    int32_t w;
+    if(obj->w_layout) {
+        w = lv_obj_get_width(obj);
+    }
+    else {
+        int32_t content_width = -1;
+        w = calc_dynamic_width(obj, lv_obj_get_style_width(obj, LV_PART_MAIN), &content_width);
+        int32_t minw = calc_dynamic_width(obj, lv_obj_get_style_min_width(obj, LV_PART_MAIN), &content_width);
+        int32_t maxw = calc_dynamic_width(obj, lv_obj_get_style_max_width(obj, LV_PART_MAIN), &content_width);
+        w = LV_CLAMP(minw, w, maxw);
+    }
+
+    int32_t h;
+    if(obj->h_layout) {
+        h = lv_obj_get_height(obj);
+    }
+    else {
+        int32_t content_height = -1;
+        h = calc_dynamic_height(obj, lv_obj_get_style_height(obj, LV_PART_MAIN), &content_height);
+        int32_t minh = calc_dynamic_height(obj, lv_obj_get_style_min_height(obj, LV_PART_MAIN), &content_height);
+        int32_t maxh = calc_dynamic_height(obj, lv_obj_get_style_max_height(obj, LV_PART_MAIN), &content_height);
+        h = LV_CLAMP(minh, h, maxh);
+    }
+
+    /*Do nothing if the size is not changed*/
+    /*It is very important else recursive resizing can occur without size change*/
+    if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h)
+        return false;
+
+    /*Invalidate the original area*/
+    lv_obj_invalidate(obj);
+
+    /*Save the original coordinates*/
+    lv_area_t ori;
+    lv_obj_get_coords(obj, &ori);
+
+    /*Check if the object inside the parent or not*/
+    lv_area_t parent_fit_area;
+    lv_obj_get_content_coords(parent, &parent_fit_area);
+
+    /*If the object is already out of the parent and its position is changes
+     *surely the scrollbars also changes so invalidate them*/
+    bool on1 = lv_area_is_in(&ori, &parent_fit_area, 0);
+    if(!on1)
+        lv_obj_scrollbar_invalidate(parent);
+
+    /*Set the length and height
+     *Be sure the content is not scrolled in an invalid position on the new size*/
+    obj->coords.y2 = obj->coords.y1 + h - 1;
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        obj->coords.x1 = obj->coords.x2 - w + 1;
+    }
+    else {
+        obj->coords.x2 = obj->coords.x1 + w - 1;
+    }
+
+    /*Call the ancestor's event handler to the object with its new coordinates*/
+    lv_obj_send_event(obj, LV_EVENT_SIZE_CHANGED, &ori);
+
+    /*Call the ancestor's event handler to the parent too*/
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, obj);
+
+    /*Invalidate the new area*/
+    lv_obj_invalidate(obj);
+
+    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*/
+    bool on2 = lv_area_is_in(&obj->coords, &parent_fit_area, 0);
+    if(on1 || (!on1 && on2))
+        lv_obj_scrollbar_invalidate(parent);
+
+    lv_obj_refresh_ext_draw_size(obj);
+
+    return true;
+}
+
+void lv_obj_set_size(lv_obj_t * obj, int32_t w, int32_t h)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_set_width(obj, w);
+    lv_obj_set_height(obj, h);
+}
+
+void lv_obj_set_width(lv_obj_t * obj, int32_t w)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_style_res_t res_w;
+    lv_style_value_t v_w;
+
+    res_w = lv_obj_get_local_style_prop(obj, LV_STYLE_WIDTH, &v_w, 0);
+
+    if((res_w == LV_STYLE_RES_FOUND && v_w.num != w) || res_w == LV_STYLE_RES_NOT_FOUND) {
+        lv_obj_set_style_width(obj, w, 0);
+    }
+}
+
+void lv_obj_set_height(lv_obj_t * obj, int32_t h)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_style_res_t res_h;
+    lv_style_value_t v_h;
+
+    res_h = lv_obj_get_local_style_prop(obj, LV_STYLE_HEIGHT, &v_h, 0);
+
+    if((res_h == LV_STYLE_RES_FOUND && v_h.num != h) || res_h == LV_STYLE_RES_NOT_FOUND) {
+        lv_obj_set_style_height(obj, h, 0);
+    }
+}
+
+void lv_obj_set_content_width(lv_obj_t * obj, int32_t w)
+{
+    int32_t left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+    int32_t right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+    lv_obj_set_width(obj, w + left + right);
+}
+
+void lv_obj_set_content_height(lv_obj_t * obj, int32_t h)
+{
+    int32_t top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
+    int32_t bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
+    lv_obj_set_height(obj, h + top + bottom);
+}
+
+void lv_obj_set_layout(lv_obj_t * obj, uint32_t layout)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_set_style_layout(obj, layout, 0);
+
+    lv_obj_mark_layout_as_dirty(obj);
+}
+
+bool lv_obj_is_layout_positioned(const lv_obj_t * obj)
+{
+    if(lv_obj_has_flag_any(obj, LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_IGNORE_LAYOUT | LV_OBJ_FLAG_FLOATING)) return false;
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent == NULL) return false;
+
+    uint32_t layout = lv_obj_get_style_layout(parent, LV_PART_MAIN);
+    if(layout) return true;
+    else return false;
+}
+
+void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
+{
+    obj->layout_inv = 1;
+
+    /*Mark the screen as dirty too to mark that there is something to do on this screen*/
+    lv_obj_t * scr = lv_obj_get_screen(obj);
+    scr->scr_layout_inv = 1;
+
+    /*Make the display refreshing*/
+    lv_display_t * disp = lv_obj_get_display(scr);
+    lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
+}
+
+void lv_obj_update_layout(const lv_obj_t * obj)
+{
+    if(update_layout_mutex) {
+        LV_LOG_TRACE("Already running, returning");
+        return;
+    }
+    LV_PROFILER_LAYOUT_BEGIN;
+    update_layout_mutex = true;
+
+    lv_obj_t * scr = lv_obj_get_screen(obj);
+    /*Repeat until there are no more layout invalidations*/
+    while(scr->scr_layout_inv) {
+        LV_LOG_TRACE("Layout update begin");
+        scr->scr_layout_inv = 0;
+        layout_update_core(scr);
+        LV_LOG_TRACE("Layout update end");
+    }
+
+    update_layout_mutex = false;
+    LV_PROFILER_LAYOUT_END;
+}
+
+void lv_obj_set_align(lv_obj_t * obj, lv_align_t align)
+{
+    lv_obj_set_style_align(obj, align, 0);
+}
+
+void lv_obj_align(lv_obj_t * obj, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
+{
+    lv_obj_set_style_align(obj, align, 0);
+    lv_obj_set_pos(obj, x_ofs, y_ofs);
+}
+
+void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_update_layout(obj);
+    if(base == NULL) base = lv_obj_get_parent(obj);
+
+    LV_ASSERT_OBJ(base, MY_CLASS);
+
+    int32_t x = 0;
+    int32_t y = 0;
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+
+    LV_ASSERT_OBJ(parent, MY_CLASS);
+
+    int32_t pleft = lv_obj_get_style_space_left(parent, LV_PART_MAIN);
+    int32_t ptop = lv_obj_get_style_space_top(parent, LV_PART_MAIN);
+
+    int32_t bleft = lv_obj_get_style_space_left(base, LV_PART_MAIN);
+    int32_t btop = lv_obj_get_style_space_top(base, LV_PART_MAIN);
+
+    if(align == LV_ALIGN_DEFAULT) {
+        if(lv_obj_get_style_base_dir(base, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_ALIGN_TOP_RIGHT;
+        else align = LV_ALIGN_TOP_LEFT;
+    }
+
+    switch(align) {
+        case LV_ALIGN_CENTER:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
+
+        case LV_ALIGN_TOP_LEFT:
+            x = bleft;
+            y = btop;
+            break;
+
+        case LV_ALIGN_TOP_MID:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = btop;
+            break;
+
+        case LV_ALIGN_TOP_RIGHT:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = btop;
+            break;
+
+        case LV_ALIGN_BOTTOM_LEFT:
+            x = bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
+        case LV_ALIGN_BOTTOM_MID:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
+
+        case LV_ALIGN_BOTTOM_RIGHT:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
+
+        case LV_ALIGN_LEFT_MID:
+            x = bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
+
+        case LV_ALIGN_RIGHT_MID:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
+
+        case LV_ALIGN_OUT_TOP_LEFT:
+            x = 0;
+            y = -lv_obj_get_height(obj);
+            break;
+
+        case LV_ALIGN_OUT_TOP_MID:
+            x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+            y = -lv_obj_get_height(obj);
+            break;
+
+        case LV_ALIGN_OUT_TOP_RIGHT:
+            x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+            y = -lv_obj_get_height(obj);
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_LEFT:
+            x = 0;
+            y = lv_obj_get_height(base);
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_MID:
+            x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+            y = lv_obj_get_height(base);
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_RIGHT:
+            x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+            y = lv_obj_get_height(base);
+            break;
+
+        case LV_ALIGN_OUT_LEFT_TOP:
+            x = -lv_obj_get_width(obj);
+            y = 0;
+            break;
+
+        case LV_ALIGN_OUT_LEFT_MID:
+            x = -lv_obj_get_width(obj);
+            y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
+            break;
+
+        case LV_ALIGN_OUT_LEFT_BOTTOM:
+            x = -lv_obj_get_width(obj);
+            y = lv_obj_get_height(base) - lv_obj_get_height(obj);
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_TOP:
+            x = lv_obj_get_width(base);
+            y = 0;
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_MID:
+            x = lv_obj_get_width(base);
+            y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_BOTTOM:
+            x = lv_obj_get_width(base);
+            y = lv_obj_get_height(base) - lv_obj_get_height(obj);
+            break;
+
+        case LV_ALIGN_DEFAULT:
+            break;
+    }
+
+    if(LV_COORD_IS_PCT(x_ofs)) x_ofs = (lv_obj_get_width(base) * LV_COORD_GET_PCT(x_ofs)) / 100;
+    if(LV_COORD_IS_PCT(y_ofs)) y_ofs = (lv_obj_get_height(base) * LV_COORD_GET_PCT(y_ofs)) / 100;
+    if(lv_obj_get_style_base_dir(parent, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        x += x_ofs + base->coords.x1 - parent->coords.x1 + lv_obj_get_scroll_right(parent) - pleft;
+    }
+    else {
+        x += x_ofs + base->coords.x1 - parent->coords.x1 + lv_obj_get_scroll_left(parent) - pleft;
+    }
+    y += y_ofs + base->coords.y1 - parent->coords.y1 + lv_obj_get_scroll_top(parent) - ptop;
+    lv_obj_set_style_align(obj, LV_ALIGN_TOP_LEFT, 0);
+    lv_obj_set_pos(obj, x, y);
+
+}
+
+void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * coords)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_area_copy(coords, &obj->coords);
+}
+
+int32_t lv_obj_get_x(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t rel_x;
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        rel_x  = obj->coords.x1 - parent->coords.x1;
+        rel_x += lv_obj_get_scroll_x(parent);
+        rel_x -= lv_obj_get_style_space_left(parent, LV_PART_MAIN);
+    }
+    else {
+        rel_x = obj->coords.x1;
+    }
+    return rel_x;
+}
+
+int32_t lv_obj_get_x2(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return lv_obj_get_x(obj) + lv_obj_get_width(obj);
+}
+
+int32_t lv_obj_get_y(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t rel_y;
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        rel_y = obj->coords.y1 - parent->coords.y1;
+        rel_y += lv_obj_get_scroll_y(parent);
+        rel_y -= lv_obj_get_style_space_top(parent, LV_PART_MAIN);
+    }
+    else {
+        rel_y = obj->coords.y1;
+    }
+    return rel_y;
+}
+
+int32_t lv_obj_get_y2(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return lv_obj_get_y(obj) + lv_obj_get_height(obj);
+}
+
+int32_t lv_obj_get_x_aligned(const lv_obj_t * obj)
+{
+    return lv_obj_get_style_x(obj, LV_PART_MAIN);
+}
+
+int32_t lv_obj_get_y_aligned(const lv_obj_t * obj)
+{
+    return lv_obj_get_style_y(obj, LV_PART_MAIN);
+}
+
+int32_t lv_obj_get_width(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return lv_area_get_width(&obj->coords);
+}
+
+int32_t lv_obj_get_height(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return lv_area_get_height(&obj->coords);
+}
+
+int32_t lv_obj_get_content_width(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+    int32_t right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+
+    return lv_obj_get_width(obj) - left - right;
+}
+
+int32_t lv_obj_get_content_height(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
+    int32_t bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
+
+    return lv_obj_get_height(obj) - top - bottom;
+}
+
+void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_get_coords(obj, area);
+    area->x1 += lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+    area->x2 -= lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+    area->y1 += lv_obj_get_style_space_top(obj, LV_PART_MAIN);
+    area->y2 -= lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
+
+}
+
+int32_t lv_obj_get_self_width(const lv_obj_t * obj)
+{
+    lv_point_t p = {0, LV_COORD_MIN};
+    lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
+    return p.x;
+}
+
+int32_t lv_obj_get_self_height(const lv_obj_t * obj)
+{
+    lv_point_t p = {LV_COORD_MIN, 0};
+    lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
+    return p.y;
+}
+
+bool lv_obj_refresh_self_size(lv_obj_t * obj)
+{
+    int32_t w_set = lv_obj_get_style_width(obj, LV_PART_MAIN);
+    int32_t h_set = lv_obj_get_style_height(obj, LV_PART_MAIN);
+    if(w_set != LV_SIZE_CONTENT && h_set != LV_SIZE_CONTENT) return false;
+
+    lv_obj_mark_layout_as_dirty(obj);
+    return true;
+}
+
+void lv_obj_refr_pos(lv_obj_t * obj)
+{
+    if(lv_obj_is_layout_positioned(obj)) return;
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    int32_t x = lv_obj_get_style_x(obj, LV_PART_MAIN);
+    int32_t y = lv_obj_get_style_y(obj, LV_PART_MAIN);
+
+    if(parent == NULL) {
+        lv_obj_move_to(obj, x, y);
+        return;
+    }
+
+    /*Handle percentage value*/
+    int32_t pw = lv_obj_get_content_width(parent);
+    int32_t ph = lv_obj_get_content_height(parent);
+    if(LV_COORD_IS_PCT(x)) {
+        if(lv_obj_get_style_width(parent, LV_PART_MAIN) == LV_SIZE_CONTENT) x = 0; /*Avoid circular dependency*/
+        else x = (pw * LV_COORD_GET_PCT(x)) / 100;
+    }
+
+    if(LV_COORD_IS_PCT(y)) {
+        if(lv_obj_get_style_height(parent, LV_PART_MAIN) == LV_SIZE_CONTENT) y = 0; /*Avoid circular dependency*/
+        y = (ph * LV_COORD_GET_PCT(y)) / 100;
+    }
+
+    /*Handle percentage value of translate*/
+    int32_t tr_x = lv_obj_get_style_translate_x(obj, LV_PART_MAIN);
+    int32_t tr_y = lv_obj_get_style_translate_y(obj, LV_PART_MAIN);
+    int32_t w = lv_obj_get_width(obj);
+    int32_t h = lv_obj_get_height(obj);
+    if(LV_COORD_IS_PCT(tr_x)) tr_x = (w * LV_COORD_GET_PCT(tr_x)) / 100;
+    if(LV_COORD_IS_PCT(tr_y)) tr_y = (h * LV_COORD_GET_PCT(tr_y)) / 100;
+
+    /*Use the translation*/
+    x += tr_x;
+    y += tr_y;
+
+    lv_align_t align = lv_obj_get_style_align(obj, LV_PART_MAIN);
+
+    if(align == LV_ALIGN_DEFAULT) {
+        if(lv_obj_get_style_base_dir(parent, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_ALIGN_TOP_RIGHT;
+        else align = LV_ALIGN_TOP_LEFT;
+    }
+
+    switch(align) {
+        case LV_ALIGN_TOP_LEFT:
+            break;
+        case LV_ALIGN_TOP_MID:
+            x += pw / 2 - w / 2;
+            break;
+        case LV_ALIGN_TOP_RIGHT:
+            x += pw - w;
+            break;
+        case LV_ALIGN_LEFT_MID:
+            y += ph / 2 - h / 2;
+            break;
+        case LV_ALIGN_BOTTOM_LEFT:
+            y += ph - h;
+            break;
+        case LV_ALIGN_BOTTOM_MID:
+            x += pw / 2 - w / 2;
+            y += ph - h;
+            break;
+        case LV_ALIGN_BOTTOM_RIGHT:
+            x += pw - w;
+            y += ph - h;
+            break;
+        case LV_ALIGN_RIGHT_MID:
+            x += pw - w;
+            y += ph / 2 - h / 2;
+            break;
+        case LV_ALIGN_CENTER:
+            x += pw / 2 - w / 2;
+            y += ph / 2 - h / 2;
+            break;
+        default:
+            break;
+    }
+
+    lv_obj_move_to(obj, x, y);
+}
+
+void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y)
+{
+    /*Convert x and y to absolute coordinates*/
+    lv_obj_t * parent = obj->parent;
+
+    if(parent) {
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_FLOATING)) {
+            x += parent->coords.x1;
+            y += parent->coords.y1;
+        }
+        else {
+            x += parent->coords.x1 - lv_obj_get_scroll_x(parent);
+            y += parent->coords.y1 - lv_obj_get_scroll_y(parent);
+        }
+
+        x += lv_obj_get_style_space_left(parent, LV_PART_MAIN);
+        y += lv_obj_get_style_space_top(parent, LV_PART_MAIN);
+    }
+
+    /*Calculate and set the movement*/
+    lv_point_t diff;
+    diff.x = x - obj->coords.x1;
+    diff.y = y - obj->coords.y1;
+
+    /*Do nothing if the position is not changed*/
+    /*It is very important else recursive positioning can
+     *occur without position change*/
+    if(diff.x == 0 && diff.y == 0) return;
+
+    /*Invalidate the original area*/
+    lv_obj_invalidate(obj);
+
+    /*Save the original coordinates*/
+    lv_area_t ori;
+    lv_obj_get_coords(obj, &ori);
+
+    /*Check if the object inside the parent or not*/
+    lv_area_t parent_fit_area;
+    bool on1 = false;
+    if(parent) {
+        lv_obj_get_content_coords(parent, &parent_fit_area);
+
+        /*If the object is already out of the parent and its position is changes
+         *surely the scrollbars also changes so invalidate them*/
+        on1 = lv_area_is_in(&ori, &parent_fit_area, 0);
+        if(!on1) lv_obj_scrollbar_invalidate(parent);
+    }
+
+    obj->coords.x1 += diff.x;
+    obj->coords.y1 += diff.y;
+    obj->coords.x2 += diff.x;
+    obj->coords.y2 += diff.y;
+
+    lv_obj_move_children_by(obj, diff.x, diff.y, false);
+
+    /*Call the ancestor's event handler to the parent too*/
+    if(parent) lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, obj);
+
+    /*Invalidate the new area*/
+    lv_obj_invalidate(obj);
+
+    /*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*/
+    if(parent) {
+        bool on2 = lv_area_is_in(&obj->coords, &parent_fit_area, 0);
+        if(on1 || (!on1 && on2)) lv_obj_scrollbar_invalidate(parent);
+    }
+}
+
+void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, bool ignore_floating)
+{
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        if(ignore_floating && lv_obj_has_flag(child, LV_OBJ_FLAG_FLOATING)) continue;
+        child->coords.x1 += x_diff;
+        child->coords.y1 += y_diff;
+        child->coords.x2 += x_diff;
+        child->coords.y2 += y_diff;
+
+        lv_obj_move_children_by(child, x_diff, y_diff, false);
+    }
+}
+
+void lv_obj_transform_point(const lv_obj_t * obj, lv_point_t * p, lv_obj_point_transform_flag_t flags)
+{
+    lv_obj_transform_point_array(obj, p, 1, flags);
+}
+
+void lv_obj_transform_point_array(const lv_obj_t * obj, lv_point_t points[], size_t count,
+                                  lv_obj_point_transform_flag_t flags)
+{
+    if(obj) {
+        lv_layer_type_t layer_type = lv_obj_get_layer_type(obj);
+        bool do_tranf = layer_type == LV_LAYER_TYPE_TRANSFORM;
+        bool recursive = flags & LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE;
+        bool inverse = flags & LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE;
+        if(inverse) {
+            if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
+            if(do_tranf) transform_point_array(obj, points, count, inverse);
+        }
+        else {
+            if(do_tranf) transform_point_array(obj, points, count, inverse);
+            if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
+        }
+    }
+}
+
+void lv_obj_get_transformed_area(const lv_obj_t * obj, lv_area_t * area, lv_obj_point_transform_flag_t flags)
+{
+    lv_point_t p[4] = {
+        {area->x1, area->y1},
+        {area->x1, area->y2 + 1},
+        {area->x2 + 1, area->y1},
+        {area->x2 + 1, area->y2 + 1},
+    };
+
+    lv_obj_transform_point_array(obj, p, 4, flags);
+
+    area->x1 = LV_MIN4(p[0].x, p[1].x, p[2].x, p[3].x);
+    area->x2 = LV_MAX4(p[0].x, p[1].x, p[2].x, p[3].x);
+    area->y1 = LV_MIN4(p[0].y, p[1].y, p[2].y, p[3].y);
+    area->y2 = LV_MAX4(p[0].y, p[1].y, p[2].y, p[3].y);
+}
+
+void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_display_t * disp   = lv_obj_get_display(obj);
+    if(!lv_display_is_invalidation_enabled(disp)) return;
+
+    lv_area_t area_tmp;
+    lv_area_copy(&area_tmp, area);
+
+    if(!lv_obj_area_is_visible(obj, &area_tmp)) return;
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    /**
+     * When using the global matrix, the vertex coordinates of clip_area lose precision after transformation,
+     * which can be solved by expanding the redrawing area.
+     */
+    lv_area_increase(&area_tmp, 5, 5);
+#else
+    if(obj->spec_attr && obj->spec_attr->layer_type == LV_LAYER_TYPE_TRANSFORM) {
+        /*Make the area slightly larger to avoid rounding errors.
+         *5 is an empirical value*/
+        lv_area_increase(&area_tmp, 5, 5);
+    }
+#endif
+
+    lv_inv_area(lv_obj_get_display(obj),  &area_tmp);
+}
+
+void lv_obj_invalidate(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    /*Truncate the area to the object*/
+    lv_area_t obj_coords;
+    int32_t ext_size = lv_obj_get_ext_draw_size(obj);
+    lv_area_copy(&obj_coords, &obj->coords);
+    obj_coords.x1 -= ext_size;
+    obj_coords.y1 -= ext_size;
+    obj_coords.x2 += ext_size;
+    obj_coords.y2 += ext_size;
+
+    lv_obj_invalidate_area(obj, &obj_coords);
+}
+
+bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
+{
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return false;
+
+    /*Invalidate the object only if it belongs to the current or previous or one of the layers'*/
+    lv_obj_t * obj_scr = lv_obj_get_screen(obj);
+    lv_display_t * disp   = lv_obj_get_display(obj_scr);
+    if(obj_scr != lv_display_get_screen_active(disp) &&
+       obj_scr != lv_display_get_screen_prev(disp) &&
+       obj_scr != lv_display_get_layer_bottom(disp) &&
+       obj_scr != lv_display_get_layer_top(disp) &&
+       obj_scr != lv_display_get_layer_sys(disp)) {
+        return false;
+    }
+
+    /*Truncate the area to the object*/
+    lv_area_t obj_coords;
+    int32_t ext_size = lv_obj_get_ext_draw_size(obj);
+    lv_area_copy(&obj_coords, &obj->coords);
+    lv_area_increase(&obj_coords, ext_size, ext_size);
+
+    /*The area is not on the object*/
+    if(!lv_area_intersect(area, area, &obj_coords)) return false;
+
+    if(is_transformed(obj)) {
+        lv_obj_get_transformed_area(obj, area, LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE);
+    }
+
+    /*Truncate recursively to the parents*/
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    while(parent != NULL) {
+        /*If the parent is hidden then the child is hidden and won't be drawn*/
+        if(lv_obj_has_flag(parent, LV_OBJ_FLAG_HIDDEN)) return false;
+
+        /*Truncate to the parent and if no common parts break*/
+        lv_area_t parent_coords = parent->coords;
+        if(lv_obj_has_flag(parent, LV_OBJ_FLAG_OVERFLOW_VISIBLE)) {
+            int32_t parent_ext_size = lv_obj_get_ext_draw_size(parent);
+            lv_area_increase(&parent_coords, parent_ext_size, parent_ext_size);
+        }
+
+        if(is_transformed(parent)) {
+            lv_obj_get_transformed_area(parent, &parent_coords, LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE);
+        }
+        if(!lv_area_intersect(area, area, &parent_coords)) return false;
+
+        parent = lv_obj_get_parent(parent);
+    }
+
+    return true;
+}
+
+bool lv_obj_is_visible(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_area_t obj_coords;
+    int32_t ext_size = lv_obj_get_ext_draw_size(obj);
+    lv_area_copy(&obj_coords, &obj->coords);
+    obj_coords.x1 -= ext_size;
+    obj_coords.y1 -= ext_size;
+    obj_coords.x2 += ext_size;
+    obj_coords.y2 += ext_size;
+
+    return lv_obj_area_is_visible(obj, &obj_coords);
+}
+
+void lv_obj_set_ext_click_area(lv_obj_t * obj, int32_t size)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_allocate_spec_attr(obj);
+    obj->spec_attr->ext_click_pad = size;
+}
+
+void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area)
+{
+    lv_area_copy(area, &obj->coords);
+    if(obj->spec_attr) {
+        lv_area_increase(area, obj->spec_attr->ext_click_pad, obj->spec_attr->ext_click_pad);
+    }
+}
+
+bool lv_obj_hit_test(lv_obj_t * obj, const lv_point_t * point)
+{
+    if(!lv_obj_has_flag(obj, LV_OBJ_FLAG_CLICKABLE)) return false;
+
+    lv_area_t a;
+    lv_obj_get_click_area(obj, &a);
+    bool res = lv_area_is_point_on(&a, point, 0);
+    if(res == false) return false;
+
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_ADV_HITTEST)) {
+        lv_hit_test_info_t hit_info;
+        hit_info.point = point;
+        hit_info.res = true;
+        lv_obj_send_event(obj, LV_EVENT_HIT_TEST, &hit_info);
+        return hit_info.res;
+    }
+
+    return res;
+}
+
+int32_t lv_clamp_width(int32_t width, int32_t min_width, int32_t max_width, int32_t ref_width)
+{
+    if(LV_COORD_IS_PCT(min_width)) min_width = (ref_width * LV_COORD_GET_PCT(min_width)) / 100;
+    if(LV_COORD_IS_PCT(max_width)) max_width = (ref_width * LV_COORD_GET_PCT(max_width)) / 100;
+    return LV_CLAMP(min_width, width, max_width);
+}
+
+int32_t lv_clamp_height(int32_t height, int32_t min_height, int32_t max_height, int32_t ref_height)
+{
+    if(LV_COORD_IS_PCT(min_height)) min_height = (ref_height * LV_COORD_GET_PCT(min_height)) / 100;
+    if(LV_COORD_IS_PCT(max_height)) max_height = (ref_height * LV_COORD_GET_PCT(max_height)) / 100;
+    return LV_CLAMP(min_height, height, max_height);
+}
+
+void lv_obj_center(lv_obj_t * obj)
+{
+    lv_obj_align(obj, LV_ALIGN_CENTER, 0, 0);
+}
+
+void lv_obj_set_transform(lv_obj_t * obj, const lv_matrix_t * matrix)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(!matrix) {
+        lv_obj_reset_transform(obj);
+        return;
+    }
+
+    lv_obj_allocate_spec_attr(obj);
+    if(!obj->spec_attr->matrix) {
+        obj->spec_attr->matrix = lv_malloc(sizeof(lv_matrix_t));
+        LV_ASSERT_MALLOC(obj->spec_attr->matrix);
+    }
+
+    /* Invalidate the old area */
+    lv_obj_invalidate(obj);
+
+    /* Copy the matrix */
+    *obj->spec_attr->matrix = *matrix;
+
+    /* Matrix is set. Update the layer type */
+    lv_obj_update_layer_type(obj);
+
+    /* Invalidate the new area */
+    lv_obj_invalidate(obj);
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(matrix);
+    LV_LOG_WARN("Transform matrix is not used because LV_DRAW_TRANSFORM_USE_MATRIX is disabled");
+#endif
+}
+
+void lv_obj_reset_transform(lv_obj_t * obj)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(!obj->spec_attr) {
+        return;
+    }
+
+    if(!obj->spec_attr->matrix) {
+        return;
+    }
+
+    /* Invalidate the old area */
+    lv_obj_invalidate(obj);
+
+    /* Free the matrix */
+    lv_free(obj->spec_attr->matrix);
+    obj->spec_attr->matrix = NULL;
+
+    /* Matrix is cleared. Update the layer type */
+    lv_obj_update_layer_type(obj);
+
+    /* Invalidate the new area */
+    lv_obj_invalidate(obj);
+#else
+    LV_UNUSED(obj);
+#endif
+}
+
+const lv_matrix_t * lv_obj_get_transform(const lv_obj_t * obj)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(obj->spec_attr) {
+        return obj->spec_attr->matrix;
+    }
+#else
+    LV_UNUSED(obj);
+#endif
+    return NULL;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static bool is_transformed(const lv_obj_t * obj)
+{
+    while(obj) {
+        if(obj->spec_attr && obj->spec_attr->layer_type == LV_LAYER_TYPE_TRANSFORM) return true;
+        obj = obj->parent;
+    }
+    return false;
+}
+
+static int32_t calc_content_width(lv_obj_t * obj)
+{
+    int32_t scroll_x_tmp = lv_obj_get_scroll_x(obj);
+    if(obj->spec_attr) obj->spec_attr->scroll.x = 0;
+
+    int32_t space_right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+    int32_t space_left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+
+    int32_t self_w;
+    self_w = lv_obj_get_self_width(obj) + space_left + space_right;
+
+    int32_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    /*With RTL find the left most coordinate*/
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        for(i = 0; i < child_cnt; i++) {
+            int32_t child_res_tmp = LV_COORD_MIN;
+            lv_obj_t * child = obj->spec_attr->children[i];
+            if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+            if(!lv_obj_is_layout_positioned(child)) {
+                lv_align_t align = lv_obj_get_style_align(child, LV_PART_MAIN);
+                switch(align) {
+                    case LV_ALIGN_DEFAULT:
+                    case LV_ALIGN_TOP_RIGHT:
+                    case LV_ALIGN_BOTTOM_RIGHT:
+                    case LV_ALIGN_RIGHT_MID:
+                        /*Normal right aligns. Other are ignored due to possible circular dependencies*/
+                        child_res_tmp = obj->coords.x2 - child->coords.x1 + 1;
+                        break;
+                    default:
+                        /* Consider other cases only if x=0 and use the width of the object.
+                         * With x!=0 circular dependency could occur. */
+                        if(lv_obj_get_style_x(child, LV_PART_MAIN) == 0) {
+                            child_res_tmp = lv_area_get_width(&child->coords) + space_right;
+                            child_res_tmp += lv_obj_get_style_margin_left(child, LV_PART_MAIN);
+                        }
+                        break;
+                }
+            }
+            else {
+                child_res_tmp = obj->coords.x2 - child->coords.x1 + 1;
+            }
+            child_res = LV_MAX(child_res, child_res_tmp + lv_obj_get_style_margin_left(child, LV_PART_MAIN));
+        }
+        if(child_res != LV_COORD_MIN) {
+            child_res += space_left;
+        }
+    }
+    /*Else find the right most coordinate*/
+    else {
+        for(i = 0; i < child_cnt; i++) {
+            int32_t child_res_tmp = LV_COORD_MIN;
+            lv_obj_t * child = obj->spec_attr->children[i];
+            if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+            if(!lv_obj_is_layout_positioned(child)) {
+                lv_align_t align = lv_obj_get_style_align(child, LV_PART_MAIN);
+                switch(align) {
+                    case LV_ALIGN_DEFAULT:
+                    case LV_ALIGN_TOP_LEFT:
+                    case LV_ALIGN_BOTTOM_LEFT:
+                    case LV_ALIGN_LEFT_MID:
+                        /*Normal left aligns.*/
+                        child_res_tmp = child->coords.x2 - obj->coords.x1 + 1;
+                        break;
+                    default:
+                        /* Consider other cases only if x=0 and use the width of the object.
+                         * With x!=0 circular dependency could occur. */
+                        if(lv_obj_get_style_x(child, LV_PART_MAIN) == 0) {
+                            child_res_tmp = lv_area_get_width(&child->coords) + space_left;
+                            child_res_tmp += lv_obj_get_style_margin_right(child, LV_PART_MAIN);
+                        }
+                        break;
+                }
+            }
+            else {
+                child_res_tmp = child->coords.x2 - obj->coords.x1 + 1;
+            }
+
+            child_res = LV_MAX(child_res, child_res_tmp + lv_obj_get_style_margin_right(child, LV_PART_MAIN));
+        }
+
+        if(child_res != LV_COORD_MIN) {
+            child_res += space_right;
+        }
+    }
+
+    if(obj->spec_attr) obj->spec_attr->scroll.x = -scroll_x_tmp;
+
+    if(child_res == LV_COORD_MIN) return self_w;
+    return LV_MAX(child_res, self_w);
+}
+
+static int32_t calc_content_height(lv_obj_t * obj)
+{
+    int32_t scroll_y_tmp = lv_obj_get_scroll_y(obj);
+    if(obj->spec_attr) obj->spec_attr->scroll.y = 0;
+
+    int32_t space_top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
+    int32_t space_bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
+
+    int32_t self_h;
+    self_h = lv_obj_get_self_height(obj) + space_top + space_bottom;
+
+    int32_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        int32_t child_res_tmp = LV_COORD_MIN;
+        lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+        if(!lv_obj_is_layout_positioned(child)) {
+            lv_align_t align = lv_obj_get_style_align(child, LV_PART_MAIN);
+            switch(align) {
+                case LV_ALIGN_DEFAULT:
+                case LV_ALIGN_TOP_RIGHT:
+                case LV_ALIGN_TOP_MID:
+                case LV_ALIGN_TOP_LEFT:
+                    /*Normal top aligns. */
+                    child_res_tmp = child->coords.y2 - obj->coords.y1 + 1;
+                    break;
+                default:
+                    /* Consider other cases only if y=0 and use the height of the object.
+                     * With y!=0 circular dependency could occur. */
+                    if(lv_obj_get_style_y(child, LV_PART_MAIN) == 0) {
+                        child_res_tmp = lv_area_get_height(&child->coords) + space_top;
+                        child_res_tmp += lv_obj_get_style_margin_top(child, LV_PART_MAIN);
+                    }
+                    break;
+            }
+        }
+        else {
+            child_res_tmp = child->coords.y2 - obj->coords.y1 + 1;
+        }
+
+        child_res = LV_MAX(child_res, child_res_tmp + lv_obj_get_style_margin_bottom(child, LV_PART_MAIN));
+    }
+
+    if(obj->spec_attr) obj->spec_attr->scroll.y = -scroll_y_tmp;
+
+    if(child_res == LV_COORD_MIN) return self_h;
+    return LV_MAX(self_h, child_res + space_bottom);
+}
+
+static void layout_update_core(lv_obj_t * obj)
+{
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        layout_update_core(child);
+    }
+
+    if(obj->layout_inv) {
+        obj->layout_inv = 0;
+        lv_obj_refr_size(obj);
+        lv_obj_refr_pos(obj);
+
+        if(child_cnt > 0) {
+            lv_layout_apply(obj);
+        }
+    }
+
+    if(obj->readjust_scroll_after_layout) {
+        obj->readjust_scroll_after_layout = 0;
+        lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
+    }
+}
+
+static void transform_point_array(const lv_obj_t * obj, lv_point_t * p, size_t p_count, bool inv)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    const lv_matrix_t * obj_matrix = lv_obj_get_transform(obj);
+    if(obj_matrix) {
+        lv_matrix_t m;
+        lv_matrix_identity(&m);
+        lv_matrix_translate(&m, obj->coords.x1, obj->coords.y1);
+        lv_matrix_multiply(&m, obj_matrix);
+        lv_matrix_translate(&m, -obj->coords.x1, -obj->coords.y1);
+
+        if(inv) {
+            lv_matrix_t inv_m;
+            lv_matrix_inverse(&inv_m, &m);
+            m = inv_m;
+        }
+
+        for(size_t i = 0; i < p_count; i++) {
+            lv_point_precise_t p_precise = lv_point_to_precise(&p[i]);
+            lv_point_precise_t res = lv_matrix_transform_precise_point(&m, &p_precise);
+            p[i] = lv_point_from_precise(&res);
+        }
+
+        return;
+    }
+#endif /* LV_DRAW_TRANSFORM_USE_MATRIX */
+
+    int32_t angle = lv_obj_get_style_transform_rotation(obj, LV_PART_MAIN);
+    int32_t scale_x = lv_obj_get_style_transform_scale_x_safe(obj, LV_PART_MAIN);
+    int32_t scale_y = lv_obj_get_style_transform_scale_y_safe(obj, LV_PART_MAIN);
+    if(scale_x == 0) scale_x = 1;
+    if(scale_y == 0) scale_y = 1;
+
+    if(angle == 0 && scale_x == LV_SCALE_NONE && scale_y == LV_SCALE_NONE) return;
+
+    lv_point_t pivot = {
+        .x = lv_obj_get_style_transform_pivot_x(obj, LV_PART_MAIN),
+        .y = lv_obj_get_style_transform_pivot_y(obj, LV_PART_MAIN)
+    };
+
+    if(LV_COORD_IS_PCT(pivot.x)) {
+        pivot.x = (LV_COORD_GET_PCT(pivot.x) * lv_area_get_width(&obj->coords)) / 100;
+    }
+    if(LV_COORD_IS_PCT(pivot.y)) {
+        pivot.y = (LV_COORD_GET_PCT(pivot.y) * lv_area_get_height(&obj->coords)) / 100;
+    }
+
+    pivot.x = obj->coords.x1 + pivot.x;
+    pivot.y = obj->coords.y1 + pivot.y;
+
+    if(inv) {
+        angle = -angle;
+        scale_x = (256 * 256 + scale_x - 1) / scale_x;
+        scale_y = (256 * 256 + scale_y - 1) / scale_y;
+    }
+
+    lv_point_array_transform(p, p_count, angle, scale_x, scale_y, &pivot, !inv);
+}

components/easylvgl/lvgl9/src/core/lv_obj_pos.h

@@ -0,0 +1,473 @@
+/**
+ * @file lv_obj_pos.h
+ *
+ */
+
+#ifndef LV_OBJ_POS_H
+#define LV_OBJ_POS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    /** No flags */
+    LV_OBJ_POINT_TRANSFORM_FLAG_NONE = 0x00,
+
+    /** Consider the transformation properties of the parents too */
+    LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE = 0x01,
+
+    /** Execute the inverse of the transformation (-angle and 1/zoom) */
+    LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE = 0x02,
+
+    /** Both inverse and recursive*/
+    LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE_RECURSIVE = 0x03,
+} lv_obj_point_transform_flag_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Set the position of an object relative to the set alignment.
+ * @param obj       pointer to an object
+ * @param x         new x coordinate
+ * @param y         new y coordinate
+ * @note            With default alignment it's the distance from the top left corner
+ * @note            E.g. LV_ALIGN_CENTER alignment it's the offset from the center of the parent
+ * @note            The position is interpreted on the content area of the parent
+ * @note            The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
+ */
+void lv_obj_set_pos(lv_obj_t * obj, int32_t x, int32_t y);
+
+/**
+ * Set the x coordinate of an object
+ * @param obj       pointer to an object
+ * @param x         new x coordinate
+ * @note            With default alignment it's the distance from the top left corner
+ * @note            E.g. LV_ALIGN_CENTER alignment it's the offset from the center of the parent
+ * @note            The position is interpreted on the content area of the parent
+ * @note            The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
+ */
+void lv_obj_set_x(lv_obj_t * obj, int32_t x);
+
+/**
+ * Set the y coordinate of an object
+ * @param obj       pointer to an object
+ * @param y         new y coordinate
+ * @note            With default alignment it's the distance from the top left corner
+ * @note            E.g. LV_ALIGN_CENTER alignment it's the offset from the center of the parent
+ * @note            The position is interpreted on the content area of the parent
+ * @note            The values can be set in pixel or in percentage of parent size with `lv_pct(v)`
+ */
+void lv_obj_set_y(lv_obj_t * obj, int32_t y);
+
+/**
+ * Set the size of an object.
+ * @param obj       pointer to an object
+ * @param w         the new width
+ * @param h         the new height
+ * @note            possible values are:
+ *                  pixel               simple set the size accordingly
+ *                  LV_SIZE_CONTENT     set the size to involve all children in the given direction
+ *                  lv_pct(x)           to set size in percentage of the parent's content area size (the size without paddings).
+ *                                      x should be in [0..1000]% range
+ */
+void lv_obj_set_size(lv_obj_t * obj, int32_t w, int32_t h);
+
+/**
+ * Recalculate the size of the object
+ * @param obj       pointer to an object
+ * @return          true: the size has been changed
+ */
+bool lv_obj_refr_size(lv_obj_t * obj);
+
+/**
+ * Set the width of an object
+ * @param obj       pointer to an object
+ * @param w         the new width
+ * @note            possible values are:
+ *                  pixel               simple set the size accordingly
+ *                  LV_SIZE_CONTENT     set the size to involve all children in the given direction
+ *                  lv_pct(x)           to set size in percentage of the parent's content area size (the size without paddings).
+ *                                      x should be in [0..1000]% range
+ */
+void lv_obj_set_width(lv_obj_t * obj, int32_t w);
+
+/**
+ * Set the height of an object
+ * @param obj       pointer to an object
+ * @param h         the new height
+ * @note            possible values are:
+ *                  pixel               simple set the size accordingly
+ *                  LV_SIZE_CONTENT     set the size to involve all children in the given direction
+ *                  lv_pct(x)           to set size in percentage of the parent's content area size (the size without paddings).
+ *                                      x should be in [0..1000]% range
+ */
+void lv_obj_set_height(lv_obj_t * obj, int32_t h);
+
+/**
+ * Set the width reduced by the left and right padding and the border width.
+ * @param obj       pointer to an object
+ * @param w         the width without paddings in pixels
+ */
+void lv_obj_set_content_width(lv_obj_t * obj, int32_t w);
+
+/**
+ * Set the height reduced by the top and bottom padding and the border width.
+ * @param obj       pointer to an object
+ * @param h         the height without paddings in pixels
+ */
+void lv_obj_set_content_height(lv_obj_t * obj, int32_t h);
+
+/**
+ * Set a layout for an object
+ * @param obj       pointer to an object
+ * @param layout    pointer to a layout descriptor to set
+ */
+void lv_obj_set_layout(lv_obj_t * obj, uint32_t layout);
+
+/**
+ * Test whether the and object is positioned by a layout or not
+ * @param obj       pointer to an object to test
+ * @return true:    positioned by a layout; false: not positioned by a layout
+ */
+bool lv_obj_is_layout_positioned(const lv_obj_t * obj);
+
+/**
+ * Mark the object for layout update.
+ * @param obj      pointer to an object whose children need to be updated
+ */
+void lv_obj_mark_layout_as_dirty(lv_obj_t * obj);
+
+/**
+ * Update the layout of an object.
+ * @param obj      pointer to an object whose position and size needs to be updated
+ */
+void lv_obj_update_layout(const lv_obj_t * obj);
+
+/**
+ * Change the alignment of an object.
+ * @param obj       pointer to an object to align
+ * @param align     type of alignment (see 'lv_align_t' enum) `LV_ALIGN_OUT_...` can't be used.
+ */
+void lv_obj_set_align(lv_obj_t * obj, lv_align_t align);
+
+/**
+ * Change the alignment of an object and set new coordinates.
+ * Equivalent to:
+ * lv_obj_set_align(obj, align);
+ * lv_obj_set_pos(obj, x_ofs, y_ofs);
+ * @param obj       pointer to an object to align
+ * @param align     type of alignment (see 'lv_align_t' enum) `LV_ALIGN_OUT_...` can't be used.
+ * @param x_ofs     x coordinate offset after alignment
+ * @param y_ofs     y coordinate offset after alignment
+ */
+void lv_obj_align(lv_obj_t * obj, lv_align_t align, int32_t x_ofs, int32_t y_ofs);
+
+/**
+ * Align an object to another object.
+ * @param obj       pointer to an object to align
+ * @param base      pointer to another object (if NULL `obj`s parent is used). 'obj' will be aligned to it.
+ * @param align     type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs     x coordinate offset after alignment
+ * @param y_ofs     y coordinate offset after alignment
+ * @note            if the position or size of `base` changes `obj` needs to be aligned manually again
+ */
+void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, int32_t x_ofs,
+                     int32_t y_ofs);
+
+/**
+ * Align an object to the center on its parent.
+ * @param obj       pointer to an object to align
+ * @note            if the parent size changes `obj` needs to be aligned manually again
+ */
+void lv_obj_center(lv_obj_t * obj);
+
+/**
+ * Set the transform matrix of an object
+ * @param obj       pointer to an object
+ * @param matrix    pointer to a matrix to set
+ * @note `LV_DRAW_TRANSFORM_USE_MATRIX` needs to be enabled.
+ */
+void lv_obj_set_transform(lv_obj_t * obj, const lv_matrix_t * matrix);
+
+/**
+ * Reset the transform matrix of an object to identity matrix
+ * @param obj       pointer to an object
+ * @note `LV_DRAW_TRANSFORM_USE_MATRIX` needs to be enabled.
+ */
+void lv_obj_reset_transform(lv_obj_t * obj);
+
+/**
+ * Copy the coordinates of an object to an area
+ * @param obj       pointer to an object
+ * @param coords    pointer to an area to store the coordinates
+ */
+void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * coords);
+
+/**
+ * Get the x coordinate of object.
+ * @param obj       pointer to an object
+ * @return          distance of `obj` from the left side of its parent plus the parent's left padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @note            Zero return value means the object is on the left padding of the parent, and not on the left edge.
+ * @note            Scrolling of the parent doesn't change the returned value.
+ * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
+ */
+int32_t lv_obj_get_x(const lv_obj_t * obj);
+
+/**
+ * Get the x2 coordinate of object.
+ * @param obj       pointer to an object
+ * @return          distance of `obj` from the right side of its parent plus the parent's right padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @note            Zero return value means the object is on the right padding of the parent, and not on the right edge.
+ * @note            Scrolling of the parent doesn't change the returned value.
+ * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
+ */
+int32_t lv_obj_get_x2(const lv_obj_t * obj);
+
+/**
+ * Get the y coordinate of object.
+ * @param obj       pointer to an object
+ * @return          distance of `obj` from the top side of its parent plus the parent's top padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @note            Zero return value means the object is on the top padding of the parent, and not on the top edge.
+ * @note            Scrolling of the parent doesn't change the returned value.
+ * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
+ */
+int32_t lv_obj_get_y(const lv_obj_t * obj);
+
+/**
+ * Get the y2 coordinate of object.
+ * @param obj       pointer to an object
+ * @return          distance of `obj` from the bottom side of its parent plus the parent's bottom padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @note            Zero return value means the object is on the bottom padding of the parent, and not on the bottom edge.
+ * @note            Scrolling of the parent doesn't change the returned value.
+ * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
+ */
+int32_t lv_obj_get_y2(const lv_obj_t * obj);
+
+/**
+ * Get the actually set x coordinate of object, i.e. the offset from the set alignment
+ * @param obj       pointer to an object
+ * @return          the set x coordinate
+ */
+int32_t lv_obj_get_x_aligned(const lv_obj_t * obj);
+
+/**
+ * Get the actually set y coordinate of object, i.e. the offset from the set alignment
+ * @param obj       pointer to an object
+ * @return          the set y coordinate
+ */
+int32_t lv_obj_get_y_aligned(const lv_obj_t * obj);
+
+/**
+ * Get the width of an object
+ * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @return          the width in pixels
+ */
+int32_t lv_obj_get_width(const lv_obj_t * obj);
+
+/**
+ * Get the height of an object
+ * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @return          the height in pixels
+ */
+int32_t lv_obj_get_height(const lv_obj_t * obj);
+
+/**
+ * Get the width reduced by the left and right padding and the border width.
+ * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @return          the width which still fits into its parent without causing overflow (making the parent scrollable)
+ */
+int32_t lv_obj_get_content_width(const lv_obj_t * obj);
+
+/**
+ * Get the height reduced by the top and bottom padding and the border width.
+ * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @return          the height which still fits into the parent without causing overflow (making the parent scrollable)
+ */
+int32_t lv_obj_get_content_height(const lv_obj_t * obj);
+
+/**
+ * Get the area reduced by the paddings and the border width.
+ * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
+ * @param area      the area which still fits into the parent without causing overflow (making the parent scrollable)
+ */
+void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area);
+
+/**
+ * Get the width occupied by the "parts" of the widget. E.g. the width of all columns of a table.
+ * @param obj       pointer to an objects
+ * @return          the width of the virtually drawn content
+ * @note            This size independent from the real size of the widget.
+ *                  It just tells how large the internal ("virtual") content is.
+ */
+int32_t lv_obj_get_self_width(const lv_obj_t * obj);
+
+/**
+ * Get the height occupied by the "parts" of the widget. E.g. the height of all rows of a table.
+ * @param obj       pointer to an objects
+ * @return          the width of the virtually drawn content
+ * @note            This size independent from the real size of the widget.
+ *                  It just tells how large the internal ("virtual") content is.
+ */
+int32_t lv_obj_get_self_height(const lv_obj_t * obj);
+
+/**
+ * Handle if the size of the internal ("virtual") content of an object has changed.
+ * @param obj       pointer to an object
+ * @return          false: nothing happened; true: refresh happened
+ */
+bool lv_obj_refresh_self_size(lv_obj_t * obj);
+
+void lv_obj_refr_pos(lv_obj_t * obj);
+
+void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y);
+
+void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, bool ignore_floating);
+
+/**
+ * Get the transform matrix of an object
+ * @param obj       pointer to an object
+ * @return          pointer to the transform matrix or NULL if not set
+ */
+const lv_matrix_t * lv_obj_get_transform(const lv_obj_t * obj);
+
+/**
+ * Transform a point using the angle and zoom style properties of an object
+ * @param obj           pointer to an object whose style properties should be used
+ * @param p             a point to transform, the result will be written back here too
+ * @param flags         OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t`
+ */
+void lv_obj_transform_point(const lv_obj_t * obj, lv_point_t * p, lv_obj_point_transform_flag_t flags);
+
+/**
+ * Transform an array of points using the angle and zoom style properties of an object
+ * @param obj           pointer to an object whose style properties should be used
+ * @param points        the array of points to transform, the result will be written back here too
+ * @param count         number of points in the array
+ * @param flags         OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t`
+ */
+void lv_obj_transform_point_array(const lv_obj_t * obj, lv_point_t points[], size_t count,
+                                  lv_obj_point_transform_flag_t flags);
+
+/**
+ * Transform an area using the angle and zoom style properties of an object
+ * @param obj           pointer to an object whose style properties should be used
+ * @param area          an area to transform, the result will be written back here too
+ * @param flags         OR-ed valued of :cpp:enum:`lv_obj_point_transform_flag_t`
+ */
+void lv_obj_get_transformed_area(const lv_obj_t * obj, lv_area_t * area, lv_obj_point_transform_flag_t flags);
+
+/**
+ * Mark an area of an object as invalid.
+ * The area will be truncated to the object's area and marked for redraw.
+ * @param obj       pointer to an object
+ * @param           area the area to redraw
+ */
+void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area);
+
+/**
+ * Mark the object as invalid to redrawn its area
+ * @param obj       pointer to an object
+ */
+void lv_obj_invalidate(const lv_obj_t * obj);
+
+/**
+ * Tell whether an area of an object is visible (even partially) now or not
+ * @param obj       pointer to an object
+ * @param area      the are to check. The visible part of the area will be written back here.
+ * @return true     visible; false not visible (hidden, out of parent, on other screen, etc)
+ */
+bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area);
+
+/**
+ * Tell whether an object is visible (even partially) now or not
+ * @param obj       pointer to an object
+ * @return      true: visible; false not visible (hidden, out of parent, on other screen, etc)
+ */
+bool lv_obj_is_visible(const lv_obj_t * obj);
+
+/**
+ * Set the size of an extended clickable area
+ * @param obj       pointer to an object
+ * @param size      extended clickable area in all 4 directions [px]
+ */
+void lv_obj_set_ext_click_area(lv_obj_t * obj, int32_t size);
+
+/**
+ * Get the an area where to object can be clicked.
+ * It's the object's normal area plus the extended click area.
+ * @param obj       pointer to an object
+ * @param area      store the result area here
+ */
+void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area);
+
+/**
+ * Hit-test an object given a particular point in screen space.
+ * @param obj       object to hit-test
+ * @param point     screen-space point (absolute coordinate)
+ * @return          true: if the object is considered under the point
+ */
+bool lv_obj_hit_test(lv_obj_t * obj, const lv_point_t * point);
+
+/**
+ * Clamp a width between min and max width. If the min/max width is in percentage value use the ref_width
+ * @param width         width to clamp
+ * @param min_width     the minimal width
+ * @param max_width     the maximal width
+ * @param ref_width     the reference width used when min/max width is in percentage
+ * @return              the clamped width
+ */
+int32_t lv_clamp_width(int32_t width, int32_t min_width, int32_t max_width, int32_t ref_width);
+
+/**
+ * Clamp a height between min and max height. If the min/max height is in percentage value use the ref_height
+ * @param height         height to clamp
+ * @param min_height     the minimal height
+ * @param max_height     the maximal height
+ * @param ref_height     the reference height used when min/max height is in percentage
+ * @return              the clamped height
+ */
+int32_t lv_clamp_height(int32_t height, int32_t min_height, int32_t max_height, int32_t ref_height);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_POS_H*/

components/easylvgl/lvgl9/src/core/lv_obj_private.h

@@ -0,0 +1,93 @@
+/**
+ * @file lv_obj_private.h
+ *
+ */
+
+#ifndef LV_OBJ_PRIVATE_H
+#define LV_OBJ_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Special, rarely used attributes.
+ * They are allocated automatically if any elements is set.
+ */
+struct _lv_obj_spec_attr_t {
+    lv_obj_t ** children;           /**< Store the pointer of the children in an array.*/
+    lv_group_t * group_p;
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    lv_matrix_t * matrix;           /**< The transform matrix*/
+#endif
+    lv_event_list_t event_list;
+#if LV_USE_OBJ_NAME
+    const char * name;              /**< Pointer to the name */
+#endif
+    lv_point_t scroll;              /**< The current X/Y scroll offset*/
+
+    int32_t ext_click_pad;          /**< Extra click padding in all direction*/
+    int32_t ext_draw_size;          /**< EXTend the size in every direction for drawing.*/
+
+    uint16_t child_cnt;             /**< Number of children*/
+    uint16_t scrollbar_mode : 2;    /**< How to display scrollbars, see `lv_scrollbar_mode_t`*/
+    uint16_t scroll_snap_x : 2;     /**< Where to align the snappable children horizontally, see `lv_scroll_snap_t`*/
+    uint16_t scroll_snap_y : 2;     /**< Where to align the snappable children vertically*/
+    uint16_t scroll_dir : 4;        /**< The allowed scroll direction(s), see `lv_dir_t`*/
+    uint16_t layer_type : 2;        /**< Cache the layer type here. Element of lv_intermediate_layer_type_t */
+    uint16_t name_static : 1;        /**< 1: `name` was not dynamically allocated */
+};
+
+struct _lv_obj_t {
+    const lv_obj_class_t * class_p;
+    lv_obj_t * parent;
+    lv_obj_spec_attr_t * spec_attr;
+    lv_obj_style_t * styles;
+#if LV_OBJ_STYLE_CACHE
+    uint32_t style_main_prop_is_set;
+    uint32_t style_other_prop_is_set;
+#endif
+    void * user_data;
+#if LV_USE_OBJ_ID
+    void * id;
+#endif
+    lv_area_t coords;
+    lv_obj_flag_t flags;
+    uint16_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;
+    uint16_t h_layout   : 1;
+    uint16_t w_layout   : 1;
+    uint16_t is_deleting : 1;
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_property.c

@@ -0,0 +1,339 @@
+/**
+ * @file lv_obj_property.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_private.h"
+#include "../core/lv_obj.h"
+#include "../stdlib/lv_string.h"
+#include "../misc/lv_utils.h"
+#include "lv_obj_property.h"
+#include "lv_obj_class_private.h"
+
+#if LV_USE_OBJ_PROPERTY
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define HANDLE_PROPERTY_TYPE(type, field) \
+    if(!set) { \
+        value->field = ((lv_property_get_##type##_t)(prop->getter))(obj); \
+    } else { \
+        switch(LV_PROPERTY_ID_TYPE2(prop->id)) { \
+            case LV_PROPERTY_ID_INVALID: \
+                ((lv_property_set_##type##_t)(prop->setter))(obj, value->field); \
+                break; \
+            case LV_PROPERTY_TYPE_INT: \
+                ((lv_property_set_##type##_integer_t)(prop->setter))(obj, value->arg1.field, value->arg2.num); \
+                break; \
+            case LV_PROPERTY_TYPE_BOOL: \
+                ((lv_property_set_##type##_boolean_t)(prop->setter))(obj, value->arg1.field, value->arg2.enable); \
+                break; \
+            case LV_PROPERTY_TYPE_PRECISE: \
+                ((lv_property_set_##type##_precise_t)(prop->setter))(obj, value->arg1.field, value->arg2.precise); \
+                break; \
+            case LV_PROPERTY_TYPE_COLOR: \
+                ((lv_property_set_##type##_color_t)(prop->setter))(obj, value->arg1.field, value->arg2.color); \
+                break; \
+            case LV_PROPERTY_TYPE_POINTER: \
+            case LV_PROPERTY_TYPE_IMGSRC: \
+            case LV_PROPERTY_TYPE_TEXT: \
+            case LV_PROPERTY_TYPE_OBJ: \
+            case LV_PROPERTY_TYPE_DISPLAY: \
+            case LV_PROPERTY_TYPE_FONT: \
+                ((lv_property_set_##type##_pointer_t)(prop->setter))(obj, value->arg1.field, value->arg2.ptr); \
+                break; \
+        } \
+    }
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef int32_t integer;
+typedef bool boolean;
+typedef lv_value_precise_t precise;
+typedef lv_color_t color;
+typedef const void * pointer;
+
+#define DEFINE_PROPERTY_SETTER_TYPES(type) \
+    typedef void (*lv_property_set_##type##_t)(lv_obj_t *, type); \
+    typedef void (*lv_property_set_##type##_integer_t)(lv_obj_t *, type, int32_t); \
+    typedef void (*lv_property_set_##type##_boolean_t)(lv_obj_t *, type, bool); \
+    typedef void (*lv_property_set_##type##_precise_t)(lv_obj_t *, type, lv_value_precise_t); \
+    typedef void (*lv_property_set_##type##_color_t)(lv_obj_t *, type, lv_color_t); \
+    typedef void (*lv_property_set_##type##_pointer_t)(lv_obj_t *, type, const void *)
+
+DEFINE_PROPERTY_SETTER_TYPES(integer);
+DEFINE_PROPERTY_SETTER_TYPES(boolean);
+DEFINE_PROPERTY_SETTER_TYPES(precise);
+DEFINE_PROPERTY_SETTER_TYPES(color);
+DEFINE_PROPERTY_SETTER_TYPES(pointer);
+
+typedef void (*lv_property_set_point_t)(lv_obj_t *, lv_point_t *);
+typedef lv_result_t (*lv_property_setter_t)(lv_obj_t *, lv_prop_id_t, const lv_property_t *);
+
+typedef integer(*lv_property_get_integer_t)(const lv_obj_t *);
+typedef bool (*lv_property_get_boolean_t)(const lv_obj_t *);
+typedef lv_value_precise_t (*lv_property_get_precise_t)(const lv_obj_t *);
+typedef lv_color_t (*lv_property_get_color_t)(const lv_obj_t *);
+typedef void * (*lv_property_get_pointer_t)(const lv_obj_t *);
+typedef lv_point_t (*lv_property_get_point_t)(lv_obj_t *);
+
+typedef lv_result_t (*lv_property_getter_t)(const lv_obj_t *, lv_prop_id_t, lv_property_t *);
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static lv_result_t obj_property(lv_obj_t * obj, lv_prop_id_t id, lv_property_t * value, bool set);
+static int property_name_compare(const void * ref, const void * element);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t lv_obj_set_property(lv_obj_t * obj, const lv_property_t * value)
+{
+    LV_ASSERT(obj && value);
+
+    uint32_t index = LV_PROPERTY_ID_INDEX(value->id);
+    if(value->id == LV_PROPERTY_ID_INVALID || index > LV_PROPERTY_ID_ANY) {
+        LV_LOG_WARN("Invalid property id set to %p", obj);
+        return LV_RESULT_INVALID;
+    }
+
+    if(index < LV_PROPERTY_ID_START) {
+        lv_obj_set_local_style_prop(obj, index, value->style, value->selector);
+        return LV_RESULT_OK;
+    }
+
+    return obj_property(obj, value->id, (lv_property_t *)value, true);
+}
+
+lv_result_t lv_obj_set_properties(lv_obj_t * obj, const lv_property_t * value, uint32_t count)
+{
+    for(uint32_t i = 0; i < count; i++) {
+        lv_result_t result = lv_obj_set_property(obj, &value[i]);
+        if(result != LV_RESULT_OK) {
+            return result;
+        }
+    }
+
+    return LV_RESULT_OK;
+}
+
+lv_property_t lv_obj_get_property(lv_obj_t * obj, lv_prop_id_t id)
+{
+    lv_result_t result;
+    lv_property_t value = { 0 };
+
+    uint32_t index = LV_PROPERTY_ID_INDEX(id);
+    if(id == LV_PROPERTY_ID_INVALID || index > LV_PROPERTY_ID_ANY) {
+        LV_LOG_WARN("Invalid property id to get from %p", obj);
+        value.id = LV_PROPERTY_ID_INVALID;
+        value.num = 0;
+        return value;
+    }
+
+    if(index < LV_PROPERTY_ID_START) {
+        lv_obj_get_local_style_prop(obj, index, &value.style, 0);
+        value.id = id;
+        value.selector = 0;
+        return value;
+    }
+
+    result = obj_property(obj, id, &value, false);
+    if(result != LV_RESULT_OK)
+        value.id = LV_PROPERTY_ID_INVALID;
+
+    return value;
+}
+
+lv_property_t lv_obj_get_style_property(lv_obj_t * obj, lv_prop_id_t id, uint32_t selector)
+{
+    lv_property_t value;
+    uint32_t index = LV_PROPERTY_ID_INDEX(id);
+
+    if(index == LV_PROPERTY_ID_INVALID || index >= LV_PROPERTY_ID_START) {
+        LV_LOG_WARN("invalid style property id 0x%" LV_PRIx32, id);
+        value.id = LV_PROPERTY_ID_INVALID;
+        value.num = 0;
+        return value;
+    }
+
+    lv_obj_get_local_style_prop(obj, id, &value.style, selector);
+    value.id = id;
+    value.selector = selector;
+    return value;
+}
+
+lv_prop_id_t lv_style_property_get_id(const char * name)
+{
+#if LV_USE_OBJ_PROPERTY_NAME
+    lv_property_name_t * found;
+    /*Check style property*/
+    found = lv_utils_bsearch(name, lv_style_property_names, sizeof(lv_style_property_names) / sizeof(lv_property_name_t),
+                             sizeof(lv_property_name_t), property_name_compare);
+    if(found) return found->id;
+#else
+    LV_UNUSED(name);
+#endif
+    return LV_PROPERTY_ID_INVALID;
+}
+
+lv_prop_id_t lv_obj_class_property_get_id(const lv_obj_class_t * clz, const char * name)
+{
+#if LV_USE_OBJ_PROPERTY_NAME
+    const lv_property_name_t * names;
+    lv_property_name_t * found;
+
+    names = clz->property_names;
+    if(names == NULL) {
+        /* try base class*/
+        return LV_PROPERTY_ID_INVALID;
+    }
+
+    found = lv_utils_bsearch(name, names, clz->names_count, sizeof(lv_property_name_t), property_name_compare);
+    if(found) return found->id;
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(name);
+    LV_UNUSED(property_name_compare);
+#endif
+    return LV_PROPERTY_ID_INVALID;
+}
+
+lv_prop_id_t lv_obj_property_get_id(const lv_obj_t * obj, const char * name)
+{
+#if LV_USE_OBJ_PROPERTY_NAME
+    const lv_obj_class_t * clz;
+    lv_prop_id_t id;
+
+    for(clz = obj->class_p; clz; clz = clz->base_class) {
+        id = lv_obj_class_property_get_id(clz, name);
+        if(id != LV_PROPERTY_ID_INVALID) return id;
+    }
+
+    /*Check style property*/
+    id = lv_style_property_get_id(name);
+    if(id != LV_PROPERTY_ID_INVALID) return id;
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(name);
+    LV_UNUSED(property_name_compare);
+#endif
+    return LV_PROPERTY_ID_INVALID;
+}
+
+/**********************
+ *  STATIC FUNCTIONS
+ **********************/
+
+static lv_result_t obj_property(lv_obj_t * obj, lv_prop_id_t id, lv_property_t * value, bool set)
+{
+    const lv_property_ops_t * properties;
+    const lv_property_ops_t * prop;
+
+    const lv_obj_class_t * clz;
+    uint32_t index = LV_PROPERTY_ID_INDEX(id);
+
+    for(clz = obj->class_p ; clz; clz = clz->base_class) {
+        properties = clz->properties;
+        if(properties == NULL) {
+            /* try base class*/
+            continue;
+        }
+
+        if(id != LV_PROPERTY_ID_ANY && (index < clz->prop_index_start || index > clz->prop_index_end)) {
+            /* try base class*/
+            continue;
+        }
+
+        /*Check if there's setter available for this class*/
+        for(uint32_t i = 0; i < clz->properties_count; i++) {
+            prop = &properties[i];
+
+            /*pass id and value directly to widget's property method*/
+            if(prop->id == LV_PROPERTY_ID_ANY) {
+                value->id = prop->id;
+                if(set) return ((lv_property_setter_t)prop->setter)(obj, id, value);
+                else return ((lv_property_getter_t)prop->getter)(obj, id, value);
+            }
+
+            /*Not this id, check next*/
+            if(prop->id != id)
+                continue;
+
+            /*id matched but we got null pointer to functions*/
+            if(set ? prop->setter == NULL : prop->getter == NULL) {
+                LV_LOG_WARN("NULL %s provided, id: 0x%" LV_PRIx32, set ? "setter" : "getter", id);
+                return LV_RESULT_INVALID;
+            }
+
+            /*Update value id if it's a read*/
+            if(!set) value->id = prop->id;
+
+            switch(LV_PROPERTY_ID_TYPE(prop->id)) {
+                case LV_PROPERTY_TYPE_INT:
+                    HANDLE_PROPERTY_TYPE(integer, num);
+                    break;
+                case LV_PROPERTY_TYPE_BOOL:
+                    HANDLE_PROPERTY_TYPE(boolean, enable);
+                    break;
+                case LV_PROPERTY_TYPE_PRECISE:
+                    HANDLE_PROPERTY_TYPE(precise, precise);
+                    break;
+                case LV_PROPERTY_TYPE_COLOR:
+                    HANDLE_PROPERTY_TYPE(color, color);
+                    break;
+                case LV_PROPERTY_TYPE_POINTER:
+                case LV_PROPERTY_TYPE_IMGSRC:
+                case LV_PROPERTY_TYPE_TEXT:
+                case LV_PROPERTY_TYPE_OBJ:
+                case LV_PROPERTY_TYPE_DISPLAY:
+                case LV_PROPERTY_TYPE_FONT:
+                    HANDLE_PROPERTY_TYPE(pointer, ptr);
+                    break;
+                case LV_PROPERTY_TYPE_POINT: {
+                        lv_point_t * point = &value->point;
+                        if(set)((lv_property_set_point_t)(prop->setter))(obj, point);
+                        else *point = ((lv_property_get_point_t)(prop->getter))(obj);
+                        break;
+                    }
+                default: {
+                        LV_LOG_WARN("Unknown property id: 0x%08" LV_PRIx32, prop->id);
+                        return LV_RESULT_INVALID;
+                    }
+            }
+
+            return LV_RESULT_OK;
+        }
+
+        /*If no setter found, try base class then*/
+    }
+
+    LV_LOG_WARN("Unknown property id: 0x%08" LV_PRIx32, id);
+    return LV_RESULT_INVALID;
+}
+
+static int property_name_compare(const void * ref, const void * element)
+{
+    const lv_property_name_t * prop = element;
+    return lv_strcmp(ref, prop->name);
+}
+
+#endif /*LV_USE_OBJ_PROPERTY*/

components/easylvgl/lvgl9/src/core/lv_obj_property.h

@@ -0,0 +1,246 @@
+/**
+ * @file lv_obj_property.h
+ *
+ */
+
+#ifndef LV_OBJ_PROPERTY_H
+#define LV_OBJ_PROPERTY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_style.h"
+
+#if LV_USE_OBJ_PROPERTY
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/*All possible property value types*/
+#define LV_PROPERTY_TYPE_INVALID        0   /*Use default 0 as invalid to detect program outliers*/
+#define LV_PROPERTY_TYPE_INT            1   /*int32_t type*/
+#define LV_PROPERTY_TYPE_PRECISE        2   /*lv_value_precise_t, int32_t or float depending on LV_USE_FLOAT*/
+#define LV_PROPERTY_TYPE_COLOR          3   /*ARGB8888 type*/
+#define LV_PROPERTY_TYPE_POINT          4   /*lv_point_t */
+#define LV_PROPERTY_TYPE_POINTER        5   /*void * pointer*/
+#define LV_PROPERTY_TYPE_IMGSRC         6   /*Special pointer for image*/
+#define LV_PROPERTY_TYPE_TEXT           7   /*Special pointer of char* */
+#define LV_PROPERTY_TYPE_OBJ            8   /*Special pointer of lv_obj_t* */
+#define LV_PROPERTY_TYPE_DISPLAY        9   /*Special pointer of lv_display_t* */
+#define LV_PROPERTY_TYPE_FONT           10  /*Special pointer of lv_font_t* */
+#define LV_PROPERTY_TYPE_BOOL           11  /*int32_t type*/
+
+#define LV_PROPERTY_TYPE_SHIFT          28
+#define LV_PROPERTY_TYPE2_SHIFT         24
+
+/* Example:
+ * LV_PROPERTY_ID(OBJ, FLAG_CLICKABLE, LV_PROPERTY_TYPE_INT, 1),
+ * produces
+ * LV_PROPERTY_OBJ_FLAG_CLICKABLE = (LV_PROPERTY_OBJ_START + (1)) | ((LV_PROPERTY_TYPE_INT) << LV_PROPERTY_TYPE_SHIFT)
+ */
+#define LV_PROPERTY_ID(clz, name, type, index)          LV_PROPERTY_## clz ##_##name = (LV_PROPERTY_## clz ##_START + ((int)index)) | ((type) << LV_PROPERTY_TYPE_SHIFT)
+
+/* Example:
+ * LV_PROPERTY_ID2(SLIDER, VALUE, LV_PROPERTY_TYPE_INT, LV_PROPERTY_TYPE_BOOL, 0)
+ * produces
+ * LV_PROPERTY_SLIDER_VALUE = (LV_PROPERTY_SLIDER_START + (0)) | ((LV_PROPERTY_TYPE_INT) << LV_PROPERTY_TYPE_SHIFT) | ((LV_PROPERTY_TYPE_BOOL) << LV_PROPERTY_TYPE2_SHIFT)
+ */
+#define LV_PROPERTY_ID2(clz, name, type, type2, index)  LV_PROPERTY_ID(clz, name, type, index) | ((type2) << LV_PROPERTY_TYPE2_SHIFT)
+
+#define LV_PROPERTY_ID_TYPE(id) ((id) >> LV_PROPERTY_TYPE_SHIFT)
+#define LV_PROPERTY_ID_TYPE2(id) ((id) >> LV_PROPERTY_TYPE_SHIFT)
+#define LV_PROPERTY_ID_INDEX(id) ((id) & 0xfffffff)
+
+/*Set properties from an array of lv_property_t*/
+#define LV_OBJ_SET_PROPERTY_ARRAY(obj, array) lv_obj_set_properties(obj, array, sizeof(array)/sizeof(array[0]))
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Group of predefined widget ID start value.
+ */
+enum _lv_prop_id_range_boundary_t {
+    LV_PROPERTY_ID_INVALID      = 0,
+
+    /*ID 0x01 to 0xff are style ID, check lv_style_prop_t*/
+    LV_PROPERTY_STYLE_START     = 0x00,
+
+    LV_PROPERTY_ID_START        = 0x0100, /*ID smaller than 0xff is style ID*/
+    /*Define the property ID for every widget here. */
+    LV_PROPERTY_OBJ_START       = 0x0100, /* lv_obj.c */
+    LV_PROPERTY_IMAGE_START     = 0x0200, /* lv_image.c */
+    LV_PROPERTY_LABEL_START     = 0x0300, /* lv_label.c */
+    LV_PROPERTY_KEYBOARD_START  = 0x0400, /* lv_keyboard.c */
+    LV_PROPERTY_TEXTAREA_START  = 0x0500, /* lv_textarea.c */
+    LV_PROPERTY_ROLLER_START    = 0x0600, /* lv_roller.c */
+    LV_PROPERTY_DROPDOWN_START  = 0x0700, /* lv_dropdown.c */
+    LV_PROPERTY_SLIDER_START    = 0x0800, /* lv_slider.c */
+    LV_PROPERTY_ANIMIMAGE_START = 0x0900, /* lv_animimage.c */
+
+    /*Special ID, use it to extend ID and make sure it's unique and compile time determinant*/
+    LV_PROPERTY_ID_BUILTIN_LAST = 0xffff, /*ID of 0x10000 ~ 0xfffffff is reserved for user*/
+
+    LV_PROPERTY_ID_ANY          = 0x7ffffffe, /*Special ID used by lvgl to intercept all setter/getter call.*/
+};
+
+struct _lv_property_name_t {
+    const char * name;
+    lv_prop_id_t id;
+};
+
+typedef struct {
+    lv_prop_id_t id;
+    union {
+        int32_t num;                /**< Signed integer number (enums or "normal" numbers)*/
+        uint32_t num_u;             /**< Unsigned integer number (opacity, Booleans)  */
+        bool enable;                /**< Booleans */
+        const void * ptr;           /**< Constant pointers  (font, cone text, etc.) */
+        lv_color_t color;           /**< Colors */
+        lv_value_precise_t precise; /**< float or int for precise value */
+        lv_point_t point;           /**< Point, contains two int32_t */
+
+        struct {
+            /**
+             * Note that place struct member `style` at first place is intended.
+             * `style` shares same memory with `num`, `ptr`, `color`.
+             * So we set the style value directly without using `prop.style.num`.
+             *
+             * E.g.
+             *
+             * static const lv_property_t obj_pos_x = {
+             *      .id = LV_PROPERTY_STYLE_X,
+             *      .num = 123,
+             *      .selector = LV_STATE_PRESSED,
+             * }
+             *
+             * instead of:
+             * static const lv_property_t obj_pos_x = {
+             *      .id = LV_PROPERTY_STYLE_X,
+             *      .style.num = 123, // note this line.
+             *      .selector = LV_STATE_PRESSED,
+             * }
+             */
+            lv_style_value_t style; /**< Make sure it's the first element in struct. */
+            uint32_t selector;      /**< Style selector, lv_part_t | lv_state_t */
+        };
+
+        /**
+         * For some properties like slider range, it contains two simple (4-byte) values
+         * so we can use `arg1.num` and `arg2.num` to set the argument.
+         */
+        struct {
+            union {
+                int32_t num;
+                uint32_t num_u;
+                bool enable;
+                const void * ptr;
+                lv_color_t color;
+                lv_value_precise_t precise;
+            } arg1, arg2;
+        };
+    };
+} lv_property_t;
+
+typedef struct {
+    lv_prop_id_t id;
+
+    void * setter;      /**< Callback used to set property. */
+    void * getter;      /**< Callback used to get property. */
+} lv_property_ops_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set Widget property.
+ * @param obj       pointer to Widget
+ * @param value     property value to set
+ * @return          return LV_RESULT_OK if call succeeded
+ */
+lv_result_t lv_obj_set_property(lv_obj_t * obj, const lv_property_t * value);
+
+/**
+ * Set multiple Widget properties. Helper `LV_OBJ_SET_PROPERTY_ARRAY` can be used for constant property array.
+ * @param obj       pointer to Widget
+ * @param value     property value array to set
+ * @param count     number of array elements
+ * @return          return LV_RESULT_OK if call succeeded
+ */
+lv_result_t lv_obj_set_properties(lv_obj_t * obj, const lv_property_t * value, uint32_t count);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Read property value from Widget.
+ * If id is a style property.  Style selector is 0 by default.
+ * @param obj       pointer to Widget
+ * @param id        ID of property to read
+ * @return          return property value read. The returned property ID is set to `LV_PROPERTY_ID_INVALID` if read failed.
+ */
+lv_property_t lv_obj_get_property(lv_obj_t * obj, lv_prop_id_t id);
+
+/**
+ * Read style property value from Widget
+ * @param obj       pointer to Widget
+ * @param id        ID of style property
+ * @param selector  selector for style property
+ * @return          return property value read. The returned property ID is set to `LV_PROPERTY_ID_INVALID` if read failed.
+ */
+lv_property_t lv_obj_get_style_property(lv_obj_t * obj, lv_prop_id_t id, uint32_t selector);
+
+/**
+ * Get property ID by recursively searching for name in Widget's class hierarchy, and
+ * if still not found, then search style properties.
+ * Requires to enabling `LV_USE_OBJ_PROPERTY_NAME`.
+ * @param obj       pointer to Widget whose class and base-class hierarchy are to be searched.
+ * @param name      property name
+ * @return          property ID found or `LV_PROPERTY_ID_INVALID` if not found.
+ */
+lv_prop_id_t lv_obj_property_get_id(const lv_obj_t * obj, const char * name);
+
+/**
+ * Get property ID by doing a non-recursive search for name directly in Widget class properties.
+ * Requires enabling `LV_USE_OBJ_PROPERTY_NAME`.
+ * @param clz       pointer to Widget class that has specified property.
+ * @param name      property name
+ * @return          property ID found or `LV_PROPERTY_ID_INVALID` if not found.
+ */
+lv_prop_id_t lv_obj_class_property_get_id(const lv_obj_class_t * clz, const char * name);
+
+/**
+ * Get style property ID by name. Requires enabling `LV_USE_OBJ_PROPERTY_NAME`.
+ * @param name      property name
+ * @return          property ID found or `LV_PROPERTY_ID_INVALID` if not found.
+ */
+lv_prop_id_t lv_style_property_get_id(const char * name);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#include "../widgets/property/lv_obj_property_names.h"
+#include "../widgets/property/lv_style_properties.h"
+
+#endif /*LV_USE_OBJ_PROPERTY*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_PROPERTY_H*/

components/easylvgl/lvgl9/src/core/lv_obj_scroll.c

@@ -0,0 +1,813 @@
+/**
+ * @file lv_obj_scroll.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_scroll_private.h"
+#include "../misc/lv_anim_private.h"
+#include "lv_obj_private.h"
+#include "../indev/lv_indev.h"
+#include "../indev/lv_indev_scroll.h"
+#include "../display/lv_display.h"
+#include "../misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+#define SCROLL_ANIM_TIME_MIN    200    /*ms*/
+#define SCROLL_ANIM_TIME_MAX    400    /*ms*/
+#define SCROLLBAR_MIN_SIZE      (LV_DPX(10))
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void scroll_x_anim(void * obj, int32_t v);
+static void scroll_y_anim(void * obj, int32_t v);
+static void scroll_end_cb(lv_anim_t * a);
+static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value,
+                                  lv_anim_enable_t anim_en);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+void lv_obj_set_scrollbar_mode(lv_obj_t * obj, lv_scrollbar_mode_t mode)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_allocate_spec_attr(obj);
+
+    if(obj->spec_attr->scrollbar_mode == mode) return;
+    obj->spec_attr->scrollbar_mode = mode;
+    lv_obj_invalidate(obj);
+}
+
+void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir)
+{
+    lv_obj_allocate_spec_attr(obj);
+
+    if(dir != obj->spec_attr->scroll_dir) {
+        obj->spec_attr->scroll_dir = dir;
+    }
+}
+
+void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align)
+{
+    lv_obj_allocate_spec_attr(obj);
+    obj->spec_attr->scroll_snap_x = align;
+}
+
+void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align)
+{
+    lv_obj_allocate_spec_attr(obj);
+    obj->spec_attr->scroll_snap_y = align;
+}
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+lv_scrollbar_mode_t lv_obj_get_scrollbar_mode(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return (lv_scrollbar_mode_t) obj->spec_attr->scrollbar_mode;
+    else return LV_SCROLLBAR_MODE_AUTO;
+}
+
+lv_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return (lv_dir_t) obj->spec_attr->scroll_dir;
+    else return LV_DIR_ALL;
+}
+
+lv_scroll_snap_t lv_obj_get_scroll_snap_x(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_x;
+    else return LV_SCROLL_SNAP_NONE;
+}
+
+lv_scroll_snap_t lv_obj_get_scroll_snap_y(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_y;
+    else return LV_SCROLL_SNAP_NONE;
+}
+
+int32_t lv_obj_get_scroll_x(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.x;
+}
+
+int32_t lv_obj_get_scroll_y(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
+}
+
+int32_t lv_obj_get_scroll_top(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
+}
+
+int32_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    int32_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        const lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+        int32_t tmp_y = child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_PART_MAIN);
+        child_res = LV_MAX(child_res, tmp_y);
+    }
+
+    int32_t space_top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
+    int32_t space_bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
+
+    if(child_res != LV_COORD_MIN) {
+        child_res -= (obj->coords.y2 - space_bottom);
+    }
+
+    int32_t self_h = lv_obj_get_self_height(obj);
+    self_h = self_h - (lv_obj_get_height(obj) - space_top - space_bottom);
+    self_h -= lv_obj_get_scroll_y(obj);
+    return LV_MAX(child_res, self_h);
+}
+
+int32_t lv_obj_get_scroll_left(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    /*Normally can't scroll the object out on the left.
+     *So simply use the current scroll position as "left size"*/
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) != LV_BASE_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return -obj->spec_attr->scroll.x;
+    }
+
+    /*With RTL base direction scrolling the left is normal so find the left most coordinate*/
+    int32_t space_right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+    int32_t space_left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+
+    int32_t child_res = 0;
+
+    uint32_t i;
+    int32_t x1 = LV_COORD_MAX;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        const lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+        int32_t tmp_x = child->coords.x1 - lv_obj_get_style_margin_left(child, LV_PART_MAIN);
+        x1 = LV_MIN(x1, tmp_x);
+    }
+
+    if(x1 != LV_COORD_MAX) {
+        child_res = x1;
+        child_res = (obj->coords.x1 + space_left) - child_res;
+    }
+    else {
+        child_res = LV_COORD_MIN;
+    }
+
+    int32_t self_w = lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - space_right - space_left);
+    self_w += lv_obj_get_scroll_x(obj);
+
+    return LV_MAX(child_res, self_w);
+}
+
+int32_t lv_obj_get_scroll_right(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    /*With RTL base dir can't scroll to the object out on the right.
+     *So simply use the current scroll position as "right size"*/
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return obj->spec_attr->scroll.x;
+    }
+
+    /*With other base direction (LTR) scrolling to the right is normal so find the right most coordinate*/
+    int32_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        const lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+        int32_t tmp_x = child->coords.x2 + lv_obj_get_style_margin_right(child, LV_PART_MAIN);
+        child_res = LV_MAX(child_res, tmp_x);
+    }
+
+    int32_t space_right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
+    int32_t space_left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
+
+    if(child_res != LV_COORD_MIN) {
+        child_res -= (obj->coords.x2 - space_right);
+    }
+
+    int32_t self_w;
+    self_w = lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - space_right - space_left);
+    self_w -= lv_obj_get_scroll_x(obj);
+    return LV_MAX(child_res, self_w);
+}
+
+void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end)
+{
+    lv_anim_t * a;
+    a = lv_anim_get(obj, scroll_x_anim);
+    end->x = a ? -a->end_value : lv_obj_get_scroll_x(obj);
+
+    a = lv_anim_get(obj, scroll_y_anim);
+    end->y = a ? -a->end_value : lv_obj_get_scroll_y(obj);
+}
+
+/*=====================
+ * Other functions
+ *====================*/
+
+void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
+{
+    if(dx == 0 && dy == 0) return;
+
+    /*We need to know the final sizes for bound check*/
+    lv_obj_update_layout(obj);
+
+    /*Don't let scroll more than naturally possible by the size of the content*/
+    int32_t x_current = -lv_obj_get_scroll_x(obj);
+    int32_t x_bounded = x_current + dx;
+
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) != LV_BASE_DIR_RTL) {
+        if(x_bounded > 0) x_bounded = 0;
+        if(x_bounded < 0) {
+            int32_t  scroll_max = lv_obj_get_scroll_left(obj) + lv_obj_get_scroll_right(obj);
+            if(scroll_max < 0) scroll_max = 0;
+
+            if(x_bounded < -scroll_max) x_bounded = -scroll_max;
+        }
+    }
+    else {
+        if(x_bounded < 0) x_bounded = 0;
+        if(x_bounded > 0) {
+            int32_t  scroll_max = lv_obj_get_scroll_left(obj) + lv_obj_get_scroll_right(obj);
+            if(scroll_max < 0) scroll_max = 0;
+
+            if(x_bounded > scroll_max) x_bounded = scroll_max;
+        }
+    }
+
+    /*Don't let scroll more than naturally possible by the size of the content*/
+    int32_t y_current = -lv_obj_get_scroll_y(obj);
+    int32_t y_bounded = y_current + dy;
+
+    if(y_bounded > 0) y_bounded = 0;
+    if(y_bounded < 0) {
+        int32_t  scroll_max = lv_obj_get_scroll_top(obj) + lv_obj_get_scroll_bottom(obj);
+        if(scroll_max < 0) scroll_max = 0;
+        if(y_bounded < -scroll_max) y_bounded = -scroll_max;
+    }
+
+    dx = x_bounded - x_current;
+    dy = y_bounded - y_current;
+    if(dx || dy) {
+        lv_obj_scroll_by(obj, dx, dy, anim_en);
+    }
+}
+
+void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
+{
+    if(dx == 0 && dy == 0) return;
+    if(anim_en) {
+        lv_display_t * d = lv_obj_get_display(obj);
+        lv_anim_t a;
+        lv_anim_init(&a);
+        lv_anim_set_var(&a, obj);
+        lv_anim_set_deleted_cb(&a, scroll_end_cb);
+
+        if(dx) {
+            uint32_t t = lv_anim_speed_clamped((lv_display_get_horizontal_resolution(d)) >> 1, SCROLL_ANIM_TIME_MIN,
+                                               SCROLL_ANIM_TIME_MAX);
+            lv_anim_set_duration(&a, t);
+            int32_t sx = lv_obj_get_scroll_x(obj);
+            lv_anim_set_values(&a, -sx, -sx + dx);
+            lv_anim_set_exec_cb(&a, scroll_x_anim);
+            lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
+
+            lv_result_t res;
+            res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, &a);
+            if(res != LV_RESULT_OK) return;
+            lv_anim_start(&a);
+        }
+
+        if(dy) {
+            uint32_t t = lv_anim_speed_clamped((lv_display_get_vertical_resolution(d)) >> 1, SCROLL_ANIM_TIME_MIN,
+                                               SCROLL_ANIM_TIME_MAX);
+            lv_anim_set_duration(&a, t);
+            int32_t sy = lv_obj_get_scroll_y(obj);
+            lv_anim_set_values(&a, -sy, -sy + dy);
+            lv_anim_set_exec_cb(&a,  scroll_y_anim);
+            lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
+
+            lv_result_t res;
+            res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, &a);
+            if(res != LV_RESULT_OK) return;
+            lv_anim_start(&a);
+        }
+    }
+    else {
+        /*Remove pending animations*/
+        lv_anim_delete(obj, scroll_y_anim);
+        lv_anim_delete(obj, scroll_x_anim);
+
+        lv_result_t res;
+        res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, NULL);
+        if(res != LV_RESULT_OK) return;
+
+        res = lv_obj_scroll_by_raw(obj, dx, dy);
+        if(res != LV_RESULT_OK) return;
+
+        res = lv_obj_send_event(obj, LV_EVENT_SCROLL_END, NULL);
+        if(res != LV_RESULT_OK) return;
+    }
+}
+
+void lv_obj_scroll_to(lv_obj_t * obj, int32_t x, int32_t y, lv_anim_enable_t anim_en)
+{
+    lv_obj_scroll_to_x(obj, x, anim_en);
+    lv_obj_scroll_to_y(obj, y, anim_en);
+}
+
+void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en)
+{
+    lv_anim_delete(obj, scroll_x_anim);
+
+    int32_t scroll_x = lv_obj_get_scroll_x(obj);
+    int32_t diff = -x + scroll_x;
+
+    lv_obj_scroll_by_bounded(obj, diff, 0, anim_en);
+}
+
+void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en)
+{
+    lv_anim_delete(obj, scroll_y_anim);
+
+    int32_t scroll_y = lv_obj_get_scroll_y(obj);
+    int32_t diff = -y + scroll_y;
+
+    lv_obj_scroll_by_bounded(obj, 0, diff, anim_en);
+}
+
+void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en)
+{
+    /*Be sure the screens layout is correct*/
+    lv_obj_update_layout(obj);
+
+    lv_point_t p = {0, 0};
+    scroll_area_into_view(&obj->coords, obj, &p, anim_en);
+}
+
+void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
+{
+    /*Be sure the screens layout is correct*/
+    lv_obj_update_layout(obj);
+
+    lv_point_t p = {0, 0};
+    lv_obj_t * child = obj;
+    lv_obj_t * parent = lv_obj_get_parent(child);
+    while(parent) {
+        scroll_area_into_view(&obj->coords, child, &p, anim_en);
+        child = parent;
+        parent = lv_obj_get_parent(parent);
+    }
+}
+
+lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y)
+{
+    if(x == 0 && y == 0) return LV_RESULT_OK;
+
+    lv_obj_allocate_spec_attr(obj);
+
+    obj->spec_attr->scroll.x += x;
+    obj->spec_attr->scroll.y += y;
+
+    lv_obj_move_children_by(obj, x, y, true);
+    lv_result_t res = lv_obj_send_event(obj, LV_EVENT_SCROLL, NULL);
+    if(res != LV_RESULT_OK) return res;
+    lv_obj_invalidate(obj);
+    return LV_RESULT_OK;
+}
+
+bool lv_obj_is_scrolling(const lv_obj_t * obj)
+{
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    while(indev) {
+        if(lv_indev_get_scroll_obj(indev) == obj) return true;
+        indev = lv_indev_get_next(indev);
+    }
+
+    if(lv_anim_get((lv_obj_t *)obj, scroll_x_anim) != NULL ||
+       lv_anim_get((lv_obj_t *)obj, scroll_y_anim) != NULL) {
+        return true;
+    }
+
+    return false;
+}
+
+void lv_obj_stop_scroll_anim(const lv_obj_t * obj)
+{
+    lv_anim_delete((lv_obj_t *)obj, scroll_y_anim);
+    lv_anim_delete((lv_obj_t *)obj, scroll_x_anim);
+}
+
+void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en)
+{
+    lv_obj_update_layout(obj);
+    lv_point_t p;
+    lv_indev_scroll_get_snap_dist(obj, &p);
+    if(p.x == LV_COORD_MAX || p.x == LV_COORD_MIN) p.x = 0;
+    if(p.y == LV_COORD_MAX || p.y == LV_COORD_MIN) p.y = 0;
+    lv_obj_scroll_by(obj, p.x, p.y, anim_en);
+}
+
+void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t * ver_area)
+{
+    lv_area_set(hor_area, 0, 0, -1, -1);
+    lv_area_set(ver_area, 0, 0, -1, -1);
+
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLLABLE) == false) return;
+
+    lv_scrollbar_mode_t sm = lv_obj_get_scrollbar_mode(obj);
+    if(sm == LV_SCROLLBAR_MODE_OFF)  return;
+
+    /*If there is no indev scrolling this object but `mode==active` return*/
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    if(sm == LV_SCROLLBAR_MODE_ACTIVE) {
+        while(indev) {
+            if(lv_indev_get_scroll_obj(indev) == obj) break;
+            indev = lv_indev_get_next(indev);
+        }
+        if(indev == NULL)  return;
+    }
+
+    int32_t st = lv_obj_get_scroll_top(obj);
+    int32_t sb = lv_obj_get_scroll_bottom(obj);
+    int32_t sl = lv_obj_get_scroll_left(obj);
+    int32_t sr = lv_obj_get_scroll_right(obj);
+
+    lv_dir_t dir = lv_obj_get_scroll_dir(obj);
+
+    bool ver_draw = false;
+    if((dir & LV_DIR_VER) &&
+       ((sm == LV_SCROLLBAR_MODE_ON) ||
+        (sm == LV_SCROLLBAR_MODE_AUTO && (st > 0 || sb > 0)) ||
+        (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_VER))) {
+        ver_draw = true;
+    }
+
+    bool hor_draw = false;
+    if((dir & LV_DIR_HOR) &&
+       ((sm == LV_SCROLLBAR_MODE_ON) ||
+        (sm == LV_SCROLLBAR_MODE_AUTO && (sl > 0 || sr > 0)) ||
+        (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_HOR))) {
+        hor_draw = true;
+    }
+
+    if(!hor_draw && !ver_draw) return;
+
+    bool rtl = lv_obj_get_style_base_dir(obj, LV_PART_SCROLLBAR) == LV_BASE_DIR_RTL;
+
+    int32_t top_space = lv_obj_get_style_pad_top(obj, LV_PART_SCROLLBAR);
+    int32_t bottom_space = lv_obj_get_style_pad_bottom(obj, LV_PART_SCROLLBAR);
+    int32_t left_space = lv_obj_get_style_pad_left(obj, LV_PART_SCROLLBAR);
+    int32_t right_space = lv_obj_get_style_pad_right(obj, LV_PART_SCROLLBAR);
+    int32_t thickness = lv_obj_get_style_width(obj, LV_PART_SCROLLBAR);
+    int32_t length = lv_obj_get_style_length(obj, LV_PART_SCROLLBAR);
+
+    int32_t obj_h = lv_obj_get_height(obj);
+    int32_t obj_w = lv_obj_get_width(obj);
+
+    /*Space required for the vertical and horizontal scrollbars*/
+    int32_t ver_reg_space = ver_draw ? thickness : 0;
+    int32_t hor_req_space = hor_draw ? thickness : 0;
+    int32_t rem;
+
+    if(lv_obj_get_style_bg_opa(obj, LV_PART_SCROLLBAR) <= LV_OPA_MIN &&
+       lv_obj_get_style_border_opa(obj, LV_PART_SCROLLBAR) <= LV_OPA_MIN) {
+        return;
+    }
+
+    /*Draw vertical scrollbar if the mode is ON or can be scrolled in this direction*/
+    int32_t content_h = obj_h + st + sb;
+    if(ver_draw && content_h) {
+        ver_area->y1 = obj->coords.y1;
+        ver_area->y2 = obj->coords.y2;
+        if(rtl) {
+            ver_area->x1 = obj->coords.x1 + left_space;
+            ver_area->x2 = ver_area->x1 + thickness - 1;
+        }
+        else {
+            ver_area->x2 = obj->coords.x2 - right_space;
+            ver_area->x1 = ver_area->x2 - thickness + 1;
+        }
+
+        int32_t sb_h = ((obj_h - top_space - bottom_space - hor_req_space) * obj_h) / content_h;
+        sb_h = LV_MAX(length > 0 ? length : sb_h, SCROLLBAR_MIN_SIZE); /*Style-defined size, calculated size, or minimum size*/
+        sb_h = LV_MIN(sb_h, obj_h); /*Limit scrollbar length to parent height*/
+        rem = (obj_h - top_space - bottom_space - hor_req_space) -
+              sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        int32_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
+        if(scroll_h <= 0) {
+            ver_area->y1 = obj->coords.y1 + top_space;
+            ver_area->y2 = obj->coords.y2 - bottom_space - hor_req_space - 1;
+        }
+        else {
+            int32_t sb_y = (rem * sb) / scroll_h;
+            sb_y = rem - sb_y;
+
+            ver_area->y1 = obj->coords.y1 + sb_y + top_space;
+            ver_area->y2 = ver_area->y1 + sb_h - 1;
+            if(ver_area->y1 < obj->coords.y1 + top_space) {
+                ver_area->y1 = obj->coords.y1 + top_space;
+                if(ver_area->y1 + SCROLLBAR_MIN_SIZE > ver_area->y2) {
+                    ver_area->y2 = ver_area->y1 + SCROLLBAR_MIN_SIZE;
+                }
+            }
+            if(ver_area->y2 > obj->coords.y2 - hor_req_space - bottom_space) {
+                ver_area->y2 = obj->coords.y2 - hor_req_space - bottom_space;
+                if(ver_area->y2 - SCROLLBAR_MIN_SIZE < ver_area->y1) {
+                    ver_area->y1 = ver_area->y2 - SCROLLBAR_MIN_SIZE;
+                }
+            }
+        }
+    }
+
+    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
+    int32_t content_w = obj_w + sl + sr;
+    if(hor_draw && content_w) {
+        hor_area->y2 = obj->coords.y2 - bottom_space;
+        hor_area->y1 = hor_area->y2 - thickness + 1;
+        hor_area->x1 = obj->coords.x1;
+        hor_area->x2 = obj->coords.x2;
+
+        int32_t sb_w = ((obj_w - left_space - right_space - ver_reg_space) * obj_w) / content_w;
+        sb_w = LV_MAX(length > 0 ? length : sb_w, SCROLLBAR_MIN_SIZE); /*Style-defined size, calculated size, or minimum size*/
+        sb_w = LV_MIN(sb_w, obj_w); /*Limit scrollbar length to parent width*/
+        rem = (obj_w - left_space - right_space - ver_reg_space) -
+              sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        int32_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
+        if(scroll_w <= 0) {
+            if(rtl) {
+                hor_area->x1 = obj->coords.x1 + left_space + ver_reg_space - 1;
+                hor_area->x2 = obj->coords.x2 - right_space;
+            }
+            else {
+                hor_area->x1 = obj->coords.x1 + left_space;
+                hor_area->x2 = obj->coords.x2 - right_space - ver_reg_space - 1;
+            }
+        }
+        else {
+            int32_t sb_x = (rem * sr) / scroll_w;
+            sb_x = rem - sb_x;
+
+            if(rtl) {
+                hor_area->x1 = obj->coords.x1 + sb_x + left_space + ver_reg_space;
+                hor_area->x2 = hor_area->x1 + sb_w - 1;
+                if(hor_area->x1 < obj->coords.x1 + left_space + ver_reg_space) {
+                    hor_area->x1 = obj->coords.x1 + left_space + ver_reg_space;
+                    if(hor_area->x1 + SCROLLBAR_MIN_SIZE > hor_area->x2) {
+                        hor_area->x2 = hor_area->x1 + SCROLLBAR_MIN_SIZE;
+                    }
+                }
+                if(hor_area->x2 > obj->coords.x2 - right_space) {
+                    hor_area->x2 = obj->coords.x2 - right_space;
+                    if(hor_area->x2 - SCROLLBAR_MIN_SIZE < hor_area->x1) {
+                        hor_area->x1 = hor_area->x2 - SCROLLBAR_MIN_SIZE;
+                    }
+                }
+            }
+            else {
+                hor_area->x1 = obj->coords.x1 + sb_x + left_space;
+                hor_area->x2 = hor_area->x1 + sb_w - 1;
+                if(hor_area->x1 < obj->coords.x1 + left_space) {
+                    hor_area->x1 = obj->coords.x1 + left_space;
+                    if(hor_area->x1 + SCROLLBAR_MIN_SIZE > hor_area->x2) {
+                        hor_area->x2 = hor_area->x1 + SCROLLBAR_MIN_SIZE;
+                    }
+                }
+                if(hor_area->x2 > obj->coords.x2 - ver_reg_space - right_space) {
+                    hor_area->x2 = obj->coords.x2 - ver_reg_space - right_space;
+                    if(hor_area->x2 - SCROLLBAR_MIN_SIZE < hor_area->x1) {
+                        hor_area->x1 = hor_area->x2 - SCROLLBAR_MIN_SIZE;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void lv_obj_scrollbar_invalidate(lv_obj_t * obj)
+{
+    lv_area_t hor_area;
+    lv_area_t ver_area;
+    lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+
+    if(lv_area_get_size(&hor_area) <= 0 && lv_area_get_size(&ver_area) <= 0) return;
+
+    if(lv_area_get_size(&hor_area) > 0) lv_obj_invalidate_area(obj, &hor_area);
+    if(lv_area_get_size(&ver_area) > 0) lv_obj_invalidate_area(obj, &ver_area);
+}
+
+void lv_obj_readjust_scroll(lv_obj_t * obj, lv_anim_enable_t anim_en)
+{
+    /*Be sure the bottom side is not remains scrolled in*/
+    /*With snapping the content can't be scrolled in*/
+    if(lv_obj_get_scroll_snap_y(obj) == LV_SCROLL_SNAP_NONE) {
+        int32_t st = lv_obj_get_scroll_top(obj);
+        int32_t sb = lv_obj_get_scroll_bottom(obj);
+        if(sb < 0 && st > 0) {
+            sb = LV_MIN(st, -sb);
+            lv_obj_scroll_by(obj, 0, sb, anim_en);
+        }
+    }
+
+    if(lv_obj_get_scroll_snap_x(obj) == LV_SCROLL_SNAP_NONE) {
+        int32_t sl = lv_obj_get_scroll_left(obj);
+        int32_t sr = lv_obj_get_scroll_right(obj);
+        if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) != LV_BASE_DIR_RTL) {
+            /*Be sure the left side is not remains scrolled in*/
+            if(sr < 0 && sl > 0) {
+                sr = LV_MIN(sl, -sr);
+                lv_obj_scroll_by(obj, sr, 0, anim_en);
+            }
+        }
+        else {
+            /*Be sure the right side is not remains scrolled in*/
+            if(sl < 0 && sr > 0) {
+                sr = LV_MIN(sr, -sl);
+                lv_obj_scroll_by(obj, sl, 0, anim_en);
+            }
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void scroll_x_anim(void * obj, int32_t v)
+{
+    lv_obj_scroll_by_raw(obj, v + lv_obj_get_scroll_x(obj), 0);
+}
+
+static void scroll_y_anim(void * obj, int32_t v)
+{
+    lv_obj_scroll_by_raw(obj, 0, v + lv_obj_get_scroll_y(obj));
+}
+
+static void scroll_end_cb(lv_anim_t * a)
+{
+    /*Do not sent END event if there wasn't a BEGIN*/
+    if(a->start_cb_called) lv_obj_send_event(a->var, LV_EVENT_SCROLL_END, NULL);
+}
+
+static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value,
+                                  lv_anim_enable_t anim_en)
+{
+    lv_obj_t * parent = lv_obj_get_parent(child);
+    if(!lv_obj_has_flag(parent, LV_OBJ_FLAG_SCROLLABLE)) return;
+
+    lv_dir_t scroll_dir = lv_obj_get_scroll_dir(parent);
+    int32_t snap_goal = 0;
+    int32_t act = 0;
+    const lv_area_t * area_tmp;
+
+    int32_t y_scroll = 0;
+    lv_scroll_snap_t snap_y = lv_obj_get_scroll_snap_y(parent);
+    if(snap_y != LV_SCROLL_SNAP_NONE) area_tmp = &child->coords;
+    else area_tmp = area;
+
+    int32_t stop = lv_obj_get_style_space_top(parent, LV_PART_MAIN);
+    int32_t sbottom = lv_obj_get_style_space_bottom(parent, LV_PART_MAIN);
+    int32_t top_diff = parent->coords.y1 + stop - area_tmp->y1 - scroll_value->y;
+    int32_t bottom_diff = -(parent->coords.y2 - sbottom - area_tmp->y2 - scroll_value->y);
+    int32_t parent_h = lv_obj_get_height(parent) - stop - sbottom;
+    if((top_diff >= 0 && bottom_diff >= 0)) y_scroll = 0;
+    else if(top_diff > 0) {
+        y_scroll = top_diff;
+        /*Do not let scrolling in*/
+        int32_t st = lv_obj_get_scroll_top(parent);
+        if(st - y_scroll < 0) y_scroll = 0;
+    }
+    else if(bottom_diff > 0) {
+        y_scroll = -bottom_diff;
+        /*Do not let scrolling in*/
+        int32_t sb = lv_obj_get_scroll_bottom(parent);
+        if(sb + y_scroll < 0) y_scroll = 0;
+    }
+
+    switch(snap_y) {
+        case LV_SCROLL_SNAP_START:
+            snap_goal = parent->coords.y1 + stop;
+            act = area_tmp->y1 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_END:
+            snap_goal = parent->coords.y2 - sbottom;
+            act = area_tmp->y2 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_CENTER:
+            snap_goal = parent->coords.y1 + stop + parent_h / 2;
+            act = lv_area_get_height(area_tmp) / 2 + area_tmp->y1 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_NONE:
+            break;
+    }
+
+    int32_t x_scroll = 0;
+    lv_scroll_snap_t snap_x = lv_obj_get_scroll_snap_x(parent);
+    if(snap_x != LV_SCROLL_SNAP_NONE) area_tmp = &child->coords;
+    else area_tmp = area;
+
+    int32_t sleft = lv_obj_get_style_space_left(parent, LV_PART_MAIN);
+    int32_t sright = lv_obj_get_style_space_right(parent, LV_PART_MAIN);
+    int32_t left_diff = parent->coords.x1 + sleft - area_tmp->x1 - scroll_value->x;
+    int32_t right_diff = -(parent->coords.x2 - sright - area_tmp->x2 - scroll_value->x);
+    if((left_diff >= 0 && right_diff >= 0)) x_scroll = 0;
+    else if(left_diff > 0) {
+        x_scroll = left_diff;
+        /*Do not let scrolling in*/
+        int32_t sl = lv_obj_get_scroll_left(parent);
+        if(sl - x_scroll < 0) x_scroll = 0;
+    }
+    else if(right_diff > 0) {
+        x_scroll = -right_diff;
+        /*Do not let scrolling in*/
+        int32_t sr = lv_obj_get_scroll_right(parent);
+        if(sr + x_scroll < 0) x_scroll = 0;
+    }
+
+    int32_t parent_w = lv_obj_get_width(parent) - sleft - sright;
+    switch(snap_x) {
+        case LV_SCROLL_SNAP_START:
+            snap_goal = parent->coords.x1 + sleft;
+            act = area_tmp->x1 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_END:
+            snap_goal = parent->coords.x2 - sright;
+            act = area_tmp->x2 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_CENTER:
+            snap_goal = parent->coords.x1 + sleft + parent_w / 2;
+            act = lv_area_get_width(area_tmp) / 2 + area_tmp->x1 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_NONE:
+            break;
+    }
+
+    /*Remove any pending scroll animations.*/
+    lv_anim_delete(parent, scroll_y_anim);
+    lv_anim_delete(parent, scroll_x_anim);
+
+    if((scroll_dir & LV_DIR_LEFT) == 0 && x_scroll < 0) x_scroll = 0;
+    if((scroll_dir & LV_DIR_RIGHT) == 0 && x_scroll > 0) x_scroll = 0;
+    if((scroll_dir & LV_DIR_TOP) == 0 && y_scroll < 0) y_scroll = 0;
+    if((scroll_dir & LV_DIR_BOTTOM) == 0 && y_scroll > 0) y_scroll = 0;
+
+    scroll_value->x += anim_en ? x_scroll : 0;
+    scroll_value->y += anim_en ? y_scroll : 0;
+    lv_obj_scroll_by(parent, x_scroll, y_scroll, anim_en);
+}

components/easylvgl/lvgl9/src/core/lv_obj_scroll.h

@@ -0,0 +1,301 @@
+/**
+ * @file lv_obj_scroll.h
+ *
+ */
+
+#ifndef LV_OBJ_SCROLL_H
+#define LV_OBJ_SCROLL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_area.h"
+#include "../misc/lv_anim.h"
+#include "../misc/lv_types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Can't include lv_obj.h because it includes this header file*/
+
+/** Scrollbar modes: shows when should the scrollbars be visible*/
+typedef enum {
+    LV_SCROLLBAR_MODE_OFF,      /**< Never show scrollbars*/
+    LV_SCROLLBAR_MODE_ON,       /**< Always show scrollbars*/
+    LV_SCROLLBAR_MODE_ACTIVE,   /**< Show scroll bars when Widget is being scrolled*/
+    LV_SCROLLBAR_MODE_AUTO,     /**< Show scroll bars when the content is large enough to be scrolled*/
+} lv_scrollbar_mode_t;
+
+/** Scroll span align options. Tells where to align the snappable children when scroll stops.*/
+typedef enum {
+    LV_SCROLL_SNAP_NONE,    /**< Do not align, leave where it is*/
+    LV_SCROLL_SNAP_START,   /**< Align to the left/top*/
+    LV_SCROLL_SNAP_END,     /**< Align to the right/bottom*/
+    LV_SCROLL_SNAP_CENTER   /**< Align to the center*/
+} lv_scroll_snap_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set how the scrollbars should behave.
+ * @param obj       pointer to Widget
+ * @param mode      LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+void lv_obj_set_scrollbar_mode(lv_obj_t * obj, lv_scrollbar_mode_t mode);
+
+/**
+ * Set direction Widget can be scrolled
+ * @param obj       pointer to Widget
+ * @param dir       one or more bit-wise OR-ed values of `lv_dir_t` enumeration
+ */
+void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir);
+
+/**
+ * Set where to snap the children when scrolling ends horizontally
+ * @param obj       pointer to Widget
+ * @param align     value from `lv_scroll_snap_t` enumeration
+ */
+void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align);
+
+/**
+ * Set where to snap the children when scrolling ends vertically
+ * @param obj       pointer to Widget
+ * @param align     value from `lv_scroll_snap_t` enumeration
+ */
+void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the current scroll mode (when to hide the scrollbars)
+ * @param obj       pointer to Widget
+ * @return          the current scroll mode from `lv_scrollbar_mode_t`
+ */
+lv_scrollbar_mode_t lv_obj_get_scrollbar_mode(const lv_obj_t * obj);
+
+/**
+ * Get directions Widget can be scrolled (set with `lv_obj_set_scroll_dir()`)
+ * @param obj       pointer to Widget
+ * @return          current scroll direction bit(s)
+ */
+lv_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj);
+
+/**
+ * Get where to snap child Widgets when horizontal scrolling ends.
+ * @param obj       pointer to Widget
+ * @return          current snap value from `lv_scroll_snap_t`
+ */
+lv_scroll_snap_t lv_obj_get_scroll_snap_x(const lv_obj_t * obj);
+
+/**
+ * Get where to snap child Widgets when vertical scrolling ends.
+ * @param  obj      pointer to Widget
+ * @return          current snap value from `lv_scroll_snap_t`
+ */
+lv_scroll_snap_t lv_obj_get_scroll_snap_y(const lv_obj_t * obj);
+
+/**
+ * Get current X scroll position.  Identical to `lv_obj_get_scroll_left()`.
+ * @param obj       pointer to scrollable container Widget
+ * @return          current scroll position from left edge
+ *                      - If Widget is not scrolled return 0.
+ *                      - If scrolled return > 0.
+ *                      - If scrolled inside (elastic scroll) return < 0.
+ */
+int32_t lv_obj_get_scroll_x(const lv_obj_t * obj);
+
+/**
+ * Get current Y scroll position.  Identical to `lv_obj_get_scroll_top()`.
+ * @param obj       pointer to scrollable container Widget
+ * @return          current scroll position from top edge
+ *                      - If Widget is not scrolled return 0.
+ *                      - If scrolled return > 0.
+ *                      - If scrolled inside (elastic scroll) return < 0.
+ */
+int32_t lv_obj_get_scroll_y(const lv_obj_t * obj);
+
+/**
+ * Number of pixels a scrollable container Widget can be scrolled down
+ * before its top edge appears.  When LV_OBJ_FLAG_SCROLL_ELASTIC flag
+ * is set in Widget, this value can go negative while Widget is being
+ * dragged below its normal top-edge boundary.
+ * @param obj       pointer to scrollable container Widget
+ * @return          pixels Widget can be scrolled down before its top edge appears
+ */
+int32_t lv_obj_get_scroll_top(const lv_obj_t * obj);
+
+/**
+ * Number of pixels a scrollable container Widget can be scrolled up
+ * before its bottom edge appears.  When LV_OBJ_FLAG_SCROLL_ELASTIC flag
+ * is set in Widget, this value can go negative while Widget is being
+ * dragged above its normal bottom-edge boundary.
+ * @param obj       pointer to scrollable container Widget
+ * @return          pixels Widget can be scrolled up before its bottom edge appears
+ */
+int32_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
+
+/**
+ * Number of pixels a scrollable container Widget can be scrolled right
+ * before its left edge appears.  When LV_OBJ_FLAG_SCROLL_ELASTIC flag
+ * is set in Widget, this value can go negative while Widget is being
+ * dragged farther right than its normal left-edge boundary.
+ * @param obj       pointer to scrollable container Widget
+ * @return          pixels Widget can be scrolled right before its left edge appears
+ */
+int32_t lv_obj_get_scroll_left(const lv_obj_t * obj);
+
+/**
+ * Number of pixels a scrollable container Widget can be scrolled left
+ * before its right edge appears.  When LV_OBJ_FLAG_SCROLL_ELASTIC flag
+ * is set in Widget, this value can go negative while Widget is being
+ * dragged farther left than its normal right-edge boundary.
+ * @param obj       pointer to scrollable container Widget
+ * @return          pixels Widget can be scrolled left before its right edge appears
+ */
+int32_t lv_obj_get_scroll_right(const lv_obj_t * obj);
+
+/**
+ * Get the X and Y coordinates where the scrolling will end for Widget if a scrolling animation is in progress.
+ * If no scrolling animation, give the current `x` or `y` scroll position.
+ * @param obj       pointer to scrollable Widget
+ * @param end       pointer to `lv_point_t` object in which to store result
+ */
+void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**
+ * Scroll by given amount of pixels.
+ * @param obj       pointer to scrollable Widget to scroll
+ * @param dx        pixels to scroll horizontally
+ * @param dy        pixels to scroll vertically
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ * @note            > 0 value means scroll right/bottom (show the more content on the right/bottom)
+ * @note            e.g. dy = -20 means scroll down 20 px
+ */
+void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll by given amount of pixels.
+ * `dx` and `dy` will be limited internally to allow scrolling only on the content area.
+ * @param obj       pointer to scrollable Widget to scroll
+ * @param dx        pixels to scroll horizontally
+ * @param dy        pixels to scroll vertically
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ * @note            e.g. dy = -20 means scroll down 20 px
+ */
+void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to given coordinate on Widget.
+ * `x` and `y` will be limited internally to allow scrolling only on the content area.
+ * @param obj       pointer to scrollable Widget to scroll
+ * @param x         pixels to scroll horizontally
+ * @param y         pixels to scroll vertically
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to(lv_obj_t * obj, int32_t x, int32_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to X coordinate on Widget.
+ * `x` will be limited internally to allow scrolling only on the content area.
+ * @param obj       pointer to scrollable Widget to scroll
+ * @param x         pixels to scroll horizontally
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to Y coordinate on Widget.
+ * `y` will be limited internally to allow scrolling only on the content area.
+ * @param obj       pointer to scrollable Widget to scroll
+ * @param y         pixels to scroll vertically
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll `obj`'s parent Widget until `obj` becomes visible.
+ * @param obj       pointer to Widget to scroll into view
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll `obj`'s parent Widgets recursively until `obj` becomes visible.
+ * Widget will be scrolled into view even it has nested scrollable parents.
+ * @param obj       pointer to Widget to scroll into view
+ * @param anim_en   LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en);
+
+/**
+ * Tell whether Widget is being scrolled or not at this moment
+ * @param obj   pointer to Widget
+ * @return      true: `obj` is being scrolled
+ */
+bool lv_obj_is_scrolling(const lv_obj_t * obj);
+
+/**
+ * Stop scrolling the current object
+ *
+ * @param obj The object being scrolled
+ */
+void lv_obj_stop_scroll_anim(const lv_obj_t * obj);
+
+/**
+ * Check children of `obj` and scroll `obj` to fulfill scroll_snap settings.
+ * @param obj       Widget whose children need to be checked and snapped
+ * @param anim_en   LV_ANIM_ON/OFF
+ */
+void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en);
+
+/**
+ * Get the area of the scrollbars
+ * @param obj   pointer to Widget
+ * @param hor   pointer to store the area of the horizontal scrollbar
+ * @param ver   pointer to store the area of the vertical  scrollbar
+ */
+void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor, lv_area_t * ver);
+
+/**
+ * Invalidate the area of the scrollbars
+ * @param obj       pointer to Widget
+ */
+void lv_obj_scrollbar_invalidate(lv_obj_t * obj);
+
+/**
+ * Checks if the content is scrolled "in" and adjusts it to a normal position.
+ * @param obj       pointer to Widget
+ * @param anim_en   LV_ANIM_ON/OFF
+ */
+void lv_obj_readjust_scroll(lv_obj_t * obj, lv_anim_enable_t anim_en);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_SCROLL_H*/

components/easylvgl/lvgl9/src/core/lv_obj_scroll_private.h

@@ -0,0 +1,50 @@
+/**
+ * @file lv_obj_scroll_private.h
+ *
+ */
+
+#ifndef LV_OBJ_SCROLL_PRIVATE_H
+#define LV_OBJ_SCROLL_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj_scroll.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Low level function to scroll by given x and y coordinates.
+ * `LV_EVENT_SCROLL` is sent.
+ * @param obj       pointer to an object to scroll
+ * @param x         pixels to scroll horizontally
+ * @param y         pixels to scroll vertically
+ * @return          `LV_RESULT_INVALID`: to object was deleted in `LV_EVENT_SCROLL`;
+ *                  `LV_RESULT_OK`: if the object is still valid
+ */
+lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_SCROLL_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_style.c

@@ -0,0 +1,1219 @@
+/**
+ * @file lv_obj_style.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_private.h"
+#include "../misc/lv_anim_private.h"
+#include "lv_obj_style_private.h"
+#include "lv_obj_class_private.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "../misc/lv_color.h"
+#include "../stdlib/lv_string.h"
+#include "../core/lv_global.h"
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+#define style_refr LV_GLOBAL_DEFAULT()->style_refresh
+#define style_trans_ll_p &(LV_GLOBAL_DEFAULT()->style_trans_ll)
+#define _style_custom_prop_flag_lookup_table LV_GLOBAL_DEFAULT()->style_custom_prop_flag_lookup_table
+#define STYLE_PROP_SHIFTED(prop) ((uint32_t)1 << ((prop) >> 3))
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_obj_t * obj;
+    lv_style_prop_t prop;
+    lv_style_selector_t selector;
+    lv_style_value_t start_value;
+    lv_style_value_t end_value;
+} trans_t;
+
+/**********************
+ *  GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_style_t * get_local_style(lv_obj_t * obj, lv_style_selector_t selector);
+static lv_obj_style_t * get_trans_style(lv_obj_t * obj, lv_style_selector_t selector);
+static lv_style_res_t get_prop_core(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop,
+                                    lv_style_value_t * v);
+static void report_style_change_core(void * style, lv_obj_t * obj);
+static void refresh_children_style(lv_obj_t * obj);
+static bool trans_delete(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop, trans_t * tr_limit);
+static void trans_anim_cb(void * _tr, int32_t v);
+static void trans_anim_start_cb(lv_anim_t * a);
+static void trans_anim_completed_cb(lv_anim_t * a);
+static lv_layer_type_t calculate_layer_type(lv_obj_t * obj);
+static void full_cache_refresh(lv_obj_t * obj, lv_part_t part);
+static void fade_anim_cb(void * obj, int32_t v);
+static void fade_in_anim_completed(lv_anim_t * a);
+static bool style_has_flag(const lv_style_t * style, uint32_t flag);
+static lv_style_res_t get_selector_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop,
+                                              lv_style_value_t * value_act);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_obj_style_init(void)
+{
+    lv_ll_init(style_trans_ll_p, sizeof(trans_t));
+}
+
+void lv_obj_style_deinit(void)
+{
+    lv_ll_clear(style_trans_ll_p);
+    if(_style_custom_prop_flag_lookup_table != NULL) {
+        lv_free(_style_custom_prop_flag_lookup_table);
+        _style_custom_prop_flag_lookup_table = NULL;
+    }
+}
+
+void lv_obj_add_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
+{
+    LV_ASSERT(obj->style_cnt < 63);
+
+    trans_delete(obj, selector, LV_STYLE_PROP_ANY, NULL);
+
+    lv_part_t part = lv_obj_style_get_selector_part(selector);
+
+    if(style && part == LV_PART_MAIN && style_has_flag(style, LV_STYLE_PROP_FLAG_TRANSFORM)) {
+        lv_obj_invalidate(obj);
+    }
+
+    /*Try removing the style first to be sure it won't be added twice*/
+    lv_obj_remove_style(obj, style, selector);
+
+    uint32_t i;
+    /*Go after the transition and local styles*/
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_trans) continue;
+        if(obj->styles[i].is_local) continue;
+        break;
+    }
+
+    /*Now `i` is at the first normal style. Insert the new style before this*/
+
+    /*Allocate space for the new style and shift the rest of the style to the end*/
+    obj->style_cnt++;
+    LV_ASSERT(obj->style_cnt != 0);
+    obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(lv_obj_style_t));
+    LV_ASSERT_MALLOC(obj->styles);
+
+    uint32_t j;
+    for(j = obj->style_cnt - 1; j > i ; j--) {
+        obj->styles[j] = obj->styles[j - 1];
+    }
+
+    lv_memzero(&obj->styles[i], sizeof(lv_obj_style_t));
+    obj->styles[i].style = style;
+    obj->styles[i].selector = selector;
+
+#if LV_OBJ_STYLE_CACHE
+    uint32_t * prop_is_set = part == LV_PART_MAIN ? &obj->style_main_prop_is_set : &obj->style_other_prop_is_set;
+    if(lv_style_is_const(style)) {
+        lv_style_const_prop_t * props = style->values_and_props;
+        for(i = 0; props[i].prop != LV_STYLE_PROP_INV; i++) {
+            (*prop_is_set) |= STYLE_PROP_SHIFTED(props[i].prop);
+        }
+    }
+    else {
+        lv_style_prop_t * props = (lv_style_prop_t *)style->values_and_props + style->prop_cnt * sizeof(lv_style_value_t);
+        for(i = 0; i < style->prop_cnt; i++) {
+            (*prop_is_set) |= STYLE_PROP_SHIFTED(props[i]);
+        }
+    }
+#endif
+
+    lv_obj_refresh_style(obj, selector, LV_STYLE_PROP_ANY);
+}
+
+bool lv_obj_replace_style(lv_obj_t * obj, const lv_style_t * old_style, const lv_style_t * new_style,
+                          lv_style_selector_t selector)
+{
+    lv_state_t state = lv_obj_style_get_selector_state(selector);
+    lv_part_t part = lv_obj_style_get_selector_part(selector);
+
+    /*All objects must exist*/
+    if(!obj || !old_style || !new_style || (old_style == new_style)) {
+        return false;
+    }
+
+    /*Similar to lv_obj_add_style, delete transition*/
+    trans_delete(obj, selector, LV_STYLE_PROP_ANY, NULL);
+
+    bool replaced = false;
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
+        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
+
+        /*Skip local styles and transitions*/
+        if(obj->styles[i].is_local || obj->styles[i].is_trans) {
+            continue;
+        }
+
+        /*Skip non-matching styles*/
+        if((state != LV_STATE_ANY && state_act != state) ||
+           (part != LV_PART_ANY && part_act != part) ||
+           (old_style != obj->styles[i].style)) {
+            continue;
+        }
+
+        lv_memzero(&obj->styles[i], sizeof(lv_obj_style_t));
+        obj->styles[i].style = new_style;
+        obj->styles[i].selector = selector;
+
+        replaced = true;
+        /*Don't break and continue replacing other occurrences*/
+    }
+    if(replaced) {
+        full_cache_refresh(obj, part);
+        lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ANY);
+    }
+    return replaced;
+}
+
+void lv_obj_remove_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
+{
+    lv_state_t state = lv_obj_style_get_selector_state(selector);
+    lv_part_t part = lv_obj_style_get_selector_part(selector);
+    lv_style_prop_t prop = LV_STYLE_PROP_ANY;
+    if(style && style->prop_cnt == 0) prop = LV_STYLE_PROP_INV;
+
+    if(style && part == LV_PART_MAIN && style_has_flag(style, LV_STYLE_PROP_FLAG_TRANSFORM)) {
+        lv_obj_invalidate(obj);
+    }
+
+    uint32_t i = 0;
+    bool deleted = false;
+    while(i <  obj->style_cnt) {
+        lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
+        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
+        if((state != LV_STATE_ANY && state_act != state) ||
+           (part != LV_PART_ANY && part_act != part) ||
+           (style != NULL && style != obj->styles[i].style)) {
+            i++;
+            continue;
+        }
+
+        if(obj->styles[i].is_trans) {
+            trans_delete(obj, part, LV_STYLE_PROP_ANY, NULL);
+        }
+
+        if(obj->styles[i].is_local || obj->styles[i].is_trans) {
+            if(obj->styles[i].style) lv_style_reset((lv_style_t *)obj->styles[i].style);
+            lv_free((lv_style_t *)obj->styles[i].style);
+            obj->styles[i].style = NULL;
+        }
+
+        /*Shift the styles after `i` by one*/
+        uint32_t j;
+        for(j = i; j < (uint32_t)obj->style_cnt - 1 ; j++) {
+            obj->styles[j] = obj->styles[j + 1];
+        }
+
+        obj->style_cnt--;
+        obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(lv_obj_style_t));
+
+        deleted = true;
+        /*The style from the current `i` index is removed, so `i` points to the next style.
+         *Therefore it doesn't needs to be incremented*/
+    }
+
+    if(deleted && prop != LV_STYLE_PROP_INV) {
+        full_cache_refresh(obj, part);
+        lv_obj_refresh_style(obj, part, prop);
+    }
+}
+
+void lv_obj_remove_style_all(lv_obj_t * obj)
+{
+    lv_obj_remove_style(obj, NULL, LV_PART_ANY | LV_STATE_ANY);
+}
+
+void lv_obj_report_style_change(lv_style_t * style)
+{
+    if(!style_refr) return;
+    lv_display_t * d = lv_display_get_next(NULL);
+
+    while(d) {
+        uint32_t i;
+        for(i = 0; i < d->screen_cnt; i++) {
+            report_style_change_core(style, d->screens[i]);
+        }
+        d = lv_display_get_next(d);
+    }
+}
+
+void lv_obj_refresh_style(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(!style_refr) return;
+
+    LV_PROFILER_STYLE_BEGIN;
+
+    lv_obj_invalidate(obj);
+
+    bool is_layout_refr = lv_style_prop_has_flag(prop, LV_STYLE_PROP_FLAG_LAYOUT_UPDATE);
+    bool is_ext_draw = lv_style_prop_has_flag(prop, LV_STYLE_PROP_FLAG_EXT_DRAW_UPDATE);
+    bool is_inheritable = lv_style_prop_has_flag(prop, LV_STYLE_PROP_FLAG_INHERITABLE);
+    bool is_layer_refr = lv_style_prop_has_flag(prop, LV_STYLE_PROP_FLAG_LAYER_UPDATE);
+
+    if(is_layout_refr) {
+        if(part == LV_PART_ANY ||
+           part == LV_PART_MAIN ||
+           lv_obj_get_style_height(obj, LV_PART_MAIN) == LV_SIZE_CONTENT ||
+           lv_obj_get_style_width(obj, LV_PART_MAIN) == LV_SIZE_CONTENT) {
+            lv_obj_send_event(obj, LV_EVENT_STYLE_CHANGED, NULL);
+            lv_obj_mark_layout_as_dirty(obj);
+        }
+    }
+    if((part == LV_PART_ANY || part == LV_PART_MAIN) && (prop == LV_STYLE_PROP_ANY || is_layout_refr)) {
+        lv_obj_t * parent = lv_obj_get_parent(obj);
+        if(parent) lv_obj_mark_layout_as_dirty(parent);
+    }
+
+    /*Cache the layer type*/
+    if((part == LV_PART_ANY || part == LV_PART_MAIN) && is_layer_refr) {
+        lv_obj_update_layer_type(obj);
+    }
+
+    if(prop == LV_STYLE_PROP_ANY || is_ext_draw) {
+        lv_obj_refresh_ext_draw_size(obj);
+    }
+    lv_obj_invalidate(obj);
+
+    if(prop == LV_STYLE_PROP_ANY || (is_inheritable && (is_ext_draw || is_layout_refr))) {
+        if(part != LV_PART_SCROLLBAR) {
+            refresh_children_style(obj);
+        }
+    }
+
+    LV_PROFILER_STYLE_END;
+}
+
+void lv_obj_style_set_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector, bool dis)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].style == style && obj->styles[i].selector == selector) {
+            if(dis == obj->styles[i].is_disabled) {
+                return; /*Already in the right state*/
+            }
+            obj->styles[i].is_disabled = dis;
+            full_cache_refresh(obj, lv_obj_style_get_selector_part(selector));
+            lv_obj_refresh_style(obj, selector, LV_STYLE_PROP_ANY);
+            return;
+        }
+    }
+    LV_LOG_WARN("%p style was not found on %p widget with %6" LV_PRIx32 " selector", (void *)style, (void *)obj, selector);
+}
+
+bool lv_obj_style_get_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].style == style && obj->styles[i].selector == selector) {
+            return obj->styles[i].is_disabled;
+        }
+    }
+
+    LV_LOG_WARN("%p style was not found on %p widget with %6" LV_PRIx32 " selector", (void *)style, (void *)obj, selector);
+    return false;
+}
+
+
+void lv_obj_enable_style_refresh(bool en)
+{
+    style_refr = en;
+}
+
+lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop)
+{
+    LV_ASSERT_NULL(obj)
+
+    lv_style_selector_t selector = part | obj->state;
+    lv_style_value_t value_act = { .ptr = NULL };
+    lv_style_res_t found;
+
+    found = get_selector_style_prop(obj, selector, prop, &value_act);
+    if(found == LV_STYLE_RES_FOUND) return value_act;
+
+    return lv_style_prop_get_default(prop);
+}
+
+bool lv_obj_has_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop)
+{
+    LV_ASSERT_NULL(obj)
+
+    lv_style_value_t value_act = { .ptr = NULL };
+    lv_style_res_t found;
+
+    found = get_selector_style_prop(obj, selector, prop, &value_act);
+    if(found == LV_STYLE_RES_FOUND) return true;
+
+    return false;
+}
+
+void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value,
+                                 lv_style_selector_t selector)
+{
+    LV_PROFILER_STYLE_BEGIN;
+
+    /*Stop running transitions with this property */
+    trans_delete(obj, lv_obj_style_get_selector_part(selector), prop, NULL);
+
+    lv_style_t * style = get_local_style(obj, selector);
+    if(selector == LV_PART_MAIN && lv_style_prop_has_flag(prop, LV_STYLE_PROP_FLAG_TRANSFORM)) {
+        lv_obj_invalidate(obj);
+    }
+
+    lv_style_set_prop(style, prop, value);
+
+#if LV_OBJ_STYLE_CACHE
+    uint32_t prop_shifted = STYLE_PROP_SHIFTED(prop);
+    if(lv_obj_style_get_selector_part(selector) == LV_PART_MAIN) {
+        obj->style_main_prop_is_set |= prop_shifted;
+    }
+    else {
+        obj->style_other_prop_is_set |= prop_shifted;
+    }
+#endif
+
+    lv_obj_refresh_style(obj, selector, prop);
+    LV_PROFILER_STYLE_END;
+}
+
+lv_style_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value,
+                                           lv_style_selector_t selector)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_local &&
+           obj->styles[i].selector == selector) {
+            return lv_style_get_prop(obj->styles[i].style, prop, value);
+        }
+    }
+
+    return LV_STYLE_RES_NOT_FOUND;
+}
+
+bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_selector_t selector)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    uint32_t i;
+    /*Find the style*/
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_local &&
+           obj->styles[i].selector == selector) {
+            break;
+        }
+    }
+
+    /*The style is not found*/
+    if(i == obj->style_cnt) return false;
+
+    lv_result_t res = lv_style_remove_prop((lv_style_t *)obj->styles[i].style, prop);
+    if(res == LV_RESULT_OK) {
+        full_cache_refresh(obj, lv_obj_style_get_selector_part(selector));
+        lv_obj_refresh_style(obj, selector, prop);
+    }
+
+    return res;
+}
+
+void lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t prev_state, lv_state_t new_state,
+                                    const lv_obj_style_transition_dsc_t * tr_dsc)
+{
+    trans_t * tr;
+
+    /*Get the previous and current values*/
+    obj->skip_trans = 1;
+    obj->state = prev_state;
+    lv_style_value_t v1 = lv_obj_get_style_prop(obj, part, tr_dsc->prop);
+    obj->state = new_state;
+    lv_style_value_t v2 = lv_obj_get_style_prop(obj, part, tr_dsc->prop);
+    obj->skip_trans = 0;
+
+    if(v1.ptr == v2.ptr && v1.num == v2.num && lv_color_eq(v1.color, v2.color))  return;
+    obj->state = prev_state;
+    v1 = lv_obj_get_style_prop(obj, part, tr_dsc->prop);
+    obj->state = new_state;
+
+    lv_obj_style_t * style_trans = get_trans_style(obj, part);
+    lv_style_set_prop((lv_style_t *)style_trans->style, tr_dsc->prop, v1);  /*Be sure `trans_style` has a valid value*/
+    lv_obj_refresh_style(obj, tr_dsc->selector, tr_dsc->prop);
+
+    if(tr_dsc->prop == LV_STYLE_RADIUS) {
+        if(v1.num == LV_RADIUS_CIRCLE || v2.num == LV_RADIUS_CIRCLE) {
+            int32_t whalf = lv_obj_get_width(obj) / 2;
+            int32_t hhalf = lv_obj_get_height(obj) / 2;
+            if(v1.num == LV_RADIUS_CIRCLE) v1.num = LV_MIN(whalf + 1, hhalf + 1);
+            if(v2.num == LV_RADIUS_CIRCLE) v2.num = LV_MIN(whalf + 1, hhalf + 1);
+        }
+    }
+
+    tr = lv_ll_ins_head(style_trans_ll_p);
+    LV_ASSERT_MALLOC(tr);
+    if(tr == NULL) return;
+    tr->start_value = v1;
+    tr->end_value = v2;
+    tr->obj = obj;
+    tr->prop = tr_dsc->prop;
+    tr->selector = part;
+
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, tr);
+    lv_anim_set_exec_cb(&a, trans_anim_cb);
+    lv_anim_set_start_cb(&a, trans_anim_start_cb);
+    lv_anim_set_completed_cb(&a, trans_anim_completed_cb);
+    lv_anim_set_values(&a, 0x00, 0xFF);
+    lv_anim_set_duration(&a, tr_dsc->time);
+    lv_anim_set_delay(&a, tr_dsc->delay);
+    lv_anim_set_path_cb(&a, tr_dsc->path_cb);
+    lv_anim_set_early_apply(&a, false);
+    lv_anim_set_user_data(&a, tr_dsc->user_data);
+    lv_anim_start(&a);
+}
+
+lv_style_value_t lv_obj_style_apply_color_filter(const lv_obj_t * obj, lv_part_t part, lv_style_value_t v)
+{
+#if LV_USE_COLOR_FILTER
+    if(obj == NULL) return v;
+    const lv_color_filter_dsc_t * f = lv_obj_get_style_color_filter_dsc(obj, part);
+    if(f && f->filter_cb) {
+        lv_opa_t f_opa = lv_obj_get_style_color_filter_opa(obj, part);
+        if(f_opa != 0) v.color = f->filter_cb(f, v.color, f_opa);
+    }
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(part);
+    LV_UNUSED(v);
+#endif
+    return v;
+}
+
+lv_style_state_cmp_t lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t state1, lv_state_t state2)
+{
+    lv_style_state_cmp_t res = LV_STYLE_STATE_CMP_SAME;
+
+    /*Are there any new styles for the new state?*/
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_trans) continue;
+
+        lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
+        /*The style is valid for a state but not the other*/
+        bool valid1 = state_act & (~state1) ? false : true;
+        bool valid2 = state_act & (~state2) ? false : true;
+        if(valid1 != valid2) {
+            const lv_style_t * style = obj->styles[i].style;
+            lv_style_value_t v;
+            /*If there is layout difference on the main part, return immediately. There is no more serious difference*/
+            bool layout_diff = false;
+            if(lv_style_get_prop(style, LV_STYLE_PAD_TOP, &v))layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_PAD_BOTTOM, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_PAD_LEFT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_PAD_RIGHT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_PAD_COLUMN, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_PAD_ROW, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_LAYOUT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSLATE_X, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSLATE_Y, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_WIDTH, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_HEIGHT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_MIN_WIDTH, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_MAX_WIDTH, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_MIN_HEIGHT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_MAX_HEIGHT, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_BORDER_WIDTH, &v)) layout_diff = true;
+
+            if(layout_diff) {
+                return LV_STYLE_STATE_CMP_DIFF_LAYOUT;
+            }
+
+            /*Check for draw pad changes*/
+            if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_WIDTH, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_HEIGHT, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ROTATION, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_SCALE_X, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_SCALE_Y, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_OPA, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_PAD, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_WIDTH, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_SHADOW_WIDTH, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_SHADOW_OPA, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_SHADOW_OFFSET_X, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_SHADOW_OFFSET_Y, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_SHADOW_SPREAD, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(lv_style_get_prop(style, LV_STYLE_LINE_WIDTH, &v)) res = LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
+            else if(res == LV_STYLE_STATE_CMP_SAME) res = LV_STYLE_STATE_CMP_DIFF_REDRAW;
+        }
+    }
+
+    return res;
+}
+
+void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_values(&a, 0, LV_OPA_COVER);
+    lv_anim_set_exec_cb(&a, fade_anim_cb);
+    lv_anim_set_completed_cb(&a, fade_in_anim_completed);
+    lv_anim_set_duration(&a, time);
+    lv_anim_set_delay(&a, delay);
+    lv_anim_start(&a);
+}
+
+void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_values(&a, lv_obj_get_style_opa(obj, LV_PART_MAIN), LV_OPA_TRANSP);
+    lv_anim_set_exec_cb(&a, fade_anim_cb);
+    lv_anim_set_duration(&a, time);
+    lv_anim_set_delay(&a, delay);
+    lv_anim_start(&a);
+}
+
+lv_text_align_t lv_obj_calculate_style_text_align(const lv_obj_t * obj, lv_part_t part, const char * txt)
+{
+    lv_text_align_t align = lv_obj_get_style_text_align(obj, part);
+    lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, part);
+    lv_bidi_calculate_align(&align, &base_dir, txt);
+    return align;
+}
+
+lv_opa_t lv_obj_get_style_opa_recursive(const lv_obj_t * obj, lv_part_t part)
+{
+    LV_PROFILER_STYLE_BEGIN;
+    lv_opa_t opa_obj = lv_obj_get_style_opa(obj, part);
+    if(opa_obj <= LV_OPA_MIN) {
+        LV_PROFILER_STYLE_END;
+        return LV_OPA_TRANSP;
+    }
+
+    lv_opa_t opa_final = LV_OPA_COVER;
+    if(opa_obj < LV_OPA_MAX) {
+        opa_final = LV_OPA_MIX2(opa_final, opa_obj);
+    }
+
+    if(part != LV_PART_MAIN) {
+        part = LV_PART_MAIN;
+    }
+    else {
+        obj = lv_obj_get_parent(obj);
+    }
+
+    while(obj) {
+        opa_obj = lv_obj_get_style_opa(obj, part);
+        if(opa_obj <= LV_OPA_MIN) {
+            LV_PROFILER_STYLE_END;
+            return LV_OPA_TRANSP;
+        }
+        if(opa_obj < LV_OPA_MAX) {
+            opa_final = LV_OPA_MIX2(opa_final, opa_obj);
+        }
+
+        obj = lv_obj_get_parent(obj);
+    }
+
+    if(opa_final <= LV_OPA_MIN) {
+        LV_PROFILER_STYLE_END;
+        return LV_OPA_TRANSP;
+    }
+
+    if(opa_final >= LV_OPA_MAX) {
+        LV_PROFILER_STYLE_END;
+        return LV_OPA_COVER;
+    }
+
+    LV_PROFILER_STYLE_END;
+    return opa_final;
+}
+
+void lv_obj_update_layer_type(lv_obj_t * obj)
+{
+    lv_layer_type_t layer_type = calculate_layer_type(obj);
+    if(obj->spec_attr) obj->spec_attr->layer_type = layer_type;
+    else if(layer_type != LV_LAYER_TYPE_NONE) {
+        lv_obj_allocate_spec_attr(obj);
+        obj->spec_attr->layer_type = layer_type;
+    }
+}
+
+lv_color32_t lv_obj_style_apply_recolor(const lv_obj_t * obj, lv_part_t part, lv_color32_t color)
+{
+    lv_opa_t opa = lv_obj_get_style_recolor_opa(obj, part);
+    if(opa > LV_OPA_TRANSP) {
+        lv_color_t recolor = lv_obj_get_style_recolor(obj, part);
+        color = lv_color_over32(color, lv_color_to_32(recolor, opa));
+    }
+
+    return color;
+}
+
+lv_color32_t lv_obj_get_style_recolor_recursive(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_color32_t result;
+
+    lv_color_t color = lv_obj_get_style_recolor(obj, part);
+    lv_opa_t opa = lv_obj_get_style_recolor_opa(obj, part);
+
+    result = lv_color_to_32(color, opa);
+
+    if(part != LV_PART_MAIN) {
+        part = LV_PART_MAIN;
+    }
+    else {
+        obj = lv_obj_get_parent(obj);
+    }
+
+    while(obj) {
+        result = lv_obj_style_apply_recolor(obj, part, result);
+        obj = lv_obj_get_parent(obj);
+    }
+
+    return result;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Get the local style of an object for a given part and for a given state.
+ * If the local style for the part-state pair doesn't exist allocate and return it.
+ * @param obj pointer to an object
+ * @param selector OR-ed value of parts and state for which the style should be get
+ * @return pointer to the local style
+ */
+static lv_style_t * get_local_style(lv_obj_t * obj, lv_style_selector_t selector)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_local &&
+           obj->styles[i].selector == selector) {
+            return (lv_style_t *)obj->styles[i].style;
+        }
+    }
+
+    obj->style_cnt++;
+    LV_ASSERT(obj->style_cnt != 0);
+    obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(lv_obj_style_t));
+    LV_ASSERT_MALLOC(obj->styles);
+
+    for(i = obj->style_cnt - 1; i > 0 ; i--) {
+        /*Copy only normal styles (not local and transition).
+         *The new local style will be added as the last local style*/
+        if(obj->styles[i - 1].is_local || obj->styles[i - 1].is_trans) break;
+        obj->styles[i] = obj->styles[i - 1];
+    }
+
+    lv_memzero(&obj->styles[i], sizeof(lv_obj_style_t));
+    obj->styles[i].style = lv_malloc_zeroed(sizeof(lv_style_t));
+    lv_style_init((lv_style_t *)obj->styles[i].style);
+
+    obj->styles[i].is_local = 1;
+    obj->styles[i].selector = selector;
+    return (lv_style_t *)obj->styles[i].style;
+}
+
+/**
+ * Get the transition style of an object for a given part and for a given state.
+ * If the transition style for the part-state pair doesn't exist allocate and return it.
+ * @param obj   pointer to an object
+ * @param selector OR-ed value of parts and state for which the style should be get
+ * @return pointer to the transition style
+ */
+static lv_obj_style_t * get_trans_style(lv_obj_t * obj,  lv_style_selector_t selector)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_trans && obj->styles[i].selector == selector) break;
+    }
+
+    /*Already have a transition style for it*/
+    if(i != obj->style_cnt) return &obj->styles[i];
+
+    obj->style_cnt++;
+    LV_ASSERT(obj->style_cnt != 0);
+    obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(lv_obj_style_t));
+
+    for(i = obj->style_cnt - 1; i > 0 ; i--) {
+        obj->styles[i] = obj->styles[i - 1];
+    }
+
+    lv_memzero(&obj->styles[0], sizeof(lv_obj_style_t));
+    obj->styles[0].style = lv_malloc(sizeof(lv_style_t));
+    lv_style_init((lv_style_t *)obj->styles[0].style);
+
+    obj->styles[0].is_trans = 1;
+    obj->styles[0].selector = selector;
+    return &obj->styles[0];
+}
+
+static lv_style_res_t get_prop_core(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop,
+                                    lv_style_value_t * v)
+{
+
+    const uint32_t group = (uint32_t)1 << lv_style_get_prop_group(prop);
+    const lv_part_t part = lv_obj_style_get_selector_part(selector);
+    const lv_state_t state = lv_obj_style_get_selector_state(selector);
+    const lv_state_t state_inv = ~state;
+    const bool skip_trans = (const bool) obj->skip_trans;
+    int32_t weight = -1;
+    lv_style_res_t found;
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        lv_obj_style_t * obj_style = &obj->styles[i];
+        if(obj_style->is_trans == false) break;
+        if(skip_trans) continue;
+        if(obj_style->is_disabled) continue;
+
+        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
+
+        if(part_act != part) continue;
+        if((obj_style->style->has_group & group) == 0) continue;
+        found = lv_style_get_prop_inlined(obj_style->style, prop, v);
+        if(found == LV_STYLE_RES_FOUND) {
+            return LV_STYLE_RES_FOUND;
+        }
+    }
+
+    for(; i < obj->style_cnt; i++) {
+        if((obj->styles[i].style->has_group & group) == 0) continue;
+        if(obj->styles[i].is_disabled) continue;
+        lv_obj_style_t * obj_style = &obj->styles[i];
+        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
+        if(part_act != part) continue;
+
+        /*Be sure the style not specifies other state than the requested.
+         *E.g. For HOVER+PRESS object state, HOVER style only is OK, but HOVER+FOCUS style is not*/
+        lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
+        if((state_act & state_inv)) continue;
+
+        /*Check only better candidates*/
+        if((int32_t)state_act <= weight) continue;
+
+        found = lv_style_get_prop_inlined(obj_style->style, prop, v);
+        if(found == LV_STYLE_RES_FOUND) {
+            if(state_act == state) {
+                return LV_STYLE_RES_FOUND;
+            }
+            weight = state_act;
+        }
+    }
+
+    if(weight >= 0) return LV_STYLE_RES_FOUND;
+    else return LV_STYLE_RES_NOT_FOUND;
+}
+
+/**
+ * Refresh the style of all children of an object. (Called recursively)
+ * @param style refresh objects only with this
+ * @param obj pointer to an object
+ */
+static void report_style_change_core(void * style, lv_obj_t * obj)
+{
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(style == NULL || obj->styles[i].style == style) {
+            full_cache_refresh(obj, lv_obj_style_get_selector_part(obj->styles[i].selector));
+            lv_obj_refresh_style(obj, LV_PART_ANY, LV_STYLE_PROP_ANY);
+            break;
+        }
+    }
+
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        report_style_change_core(style, obj->spec_attr->children[i]);
+    }
+}
+
+/**
+ * Recursively refresh the style of the children. Go deeper until a not NULL style is found
+ * because the NULL styles are inherited from the parent
+ * @param obj pointer to an object
+ */
+static void refresh_children_style(lv_obj_t * obj)
+{
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        lv_obj_invalidate(child);
+        lv_obj_send_event(child, LV_EVENT_STYLE_CHANGED, NULL);
+        lv_obj_invalidate(child);
+
+        refresh_children_style(child); /*Check children too*/
+    }
+}
+
+/**
+ * Remove the transition from object's part's property.
+ * - Remove the transition from `lv_obj_style_trans_ll` and free it
+ * - Delete pending transitions
+ * @param obj pointer to an object which transition(s) should be removed
+ * @param part a part of object or 0xFF to remove from all parts
+ * @param prop a property or 0xFF to remove all properties
+ * @param tr_limit delete transitions only "older" than this. `NULL` if not used
+ */
+static bool trans_delete(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop, trans_t * tr_limit)
+{
+    trans_t * tr;
+    trans_t * tr_prev;
+    bool removed = false;
+    tr = lv_ll_get_tail(style_trans_ll_p);
+    while(tr != NULL) {
+        if(tr == tr_limit) break;
+
+        /*'tr' might be deleted, so get the next object while 'tr' is valid*/
+        tr_prev = lv_ll_get_prev(style_trans_ll_p, tr);
+
+        if(tr->obj == obj && (part == tr->selector || part == LV_PART_ANY) && (prop == tr->prop || prop == LV_STYLE_PROP_ANY)) {
+            /*Remove any transitioned properties from the trans. style
+             *to allow changing it by normal styles*/
+            uint32_t i;
+            for(i = 0; i < obj->style_cnt; i++) {
+                if(obj->styles[i].is_trans && (part == LV_PART_ANY || obj->styles[i].selector == part)) {
+                    lv_style_remove_prop((lv_style_t *)obj->styles[i].style, tr->prop);
+                }
+            }
+
+            /*Free the transition descriptor too*/
+            lv_anim_delete(tr, NULL);
+            lv_ll_remove(style_trans_ll_p, tr);
+            lv_free(tr);
+            removed = true;
+
+        }
+        tr = tr_prev;
+    }
+    return removed;
+}
+
+static void trans_anim_cb(void * _tr, int32_t v)
+{
+    trans_t * tr = _tr;
+    lv_obj_t * obj = tr->obj;
+
+    uint32_t i;
+    for(i = 0; i < obj->style_cnt; i++) {
+        if(obj->styles[i].is_trans == 0 || obj->styles[i].selector != tr->selector) continue;
+
+        lv_style_value_t value_final = {0};
+        switch(tr->prop) {
+
+            case LV_STYLE_BORDER_SIDE:
+            case LV_STYLE_BORDER_POST:
+            case LV_STYLE_BLEND_MODE:
+                if(v < 255) value_final.num = tr->start_value.num;
+                else value_final.num = tr->end_value.num;
+                break;
+            case LV_STYLE_TRANSITION:
+            case LV_STYLE_TEXT_FONT:
+                if(v < 255) value_final.ptr = tr->start_value.ptr;
+                else value_final.ptr = tr->end_value.ptr;
+                break;
+            case LV_STYLE_COLOR_FILTER_DSC:
+                if(tr->start_value.ptr == NULL) value_final.ptr = tr->end_value.ptr;
+                else if(tr->end_value.ptr == NULL) value_final.ptr = tr->start_value.ptr;
+                else if(v < 128) value_final.ptr = tr->start_value.ptr;
+                else value_final.ptr = tr->end_value.ptr;
+                break;
+            case LV_STYLE_RECOLOR:
+            case LV_STYLE_BG_COLOR:
+            case LV_STYLE_BG_GRAD_COLOR:
+            case LV_STYLE_BORDER_COLOR:
+            case LV_STYLE_TEXT_COLOR:
+            case LV_STYLE_SHADOW_COLOR:
+            case LV_STYLE_OUTLINE_COLOR:
+            case LV_STYLE_IMAGE_RECOLOR:
+                if(v <= 0) value_final.color = tr->start_value.color;
+                else if(v >= 255) value_final.color = tr->end_value.color;
+                else value_final.color = lv_color_mix(tr->end_value.color, tr->start_value.color, v);
+                break;
+
+            default:
+                if(v == 0) value_final.num = tr->start_value.num;
+                else if(v == 255) value_final.num = tr->end_value.num;
+                else value_final.num = tr->start_value.num + ((int32_t)((int32_t)(tr->end_value.num - tr->start_value.num) * v) >> 8);
+                break;
+        }
+
+        lv_style_value_t old_value = {0};
+        bool refr = true;
+        if(lv_style_get_prop(obj->styles[i].style, tr->prop, &old_value)) {
+            if(value_final.ptr == old_value.ptr && lv_color_eq(value_final.color, old_value.color) &&
+               value_final.num == old_value.num) {
+                refr = false;
+            }
+        }
+        lv_style_set_prop((lv_style_t *)obj->styles[i].style, tr->prop, value_final);
+        if(refr) lv_obj_refresh_style(tr->obj, tr->selector, tr->prop);
+        break;
+
+    }
+
+}
+
+static void trans_anim_start_cb(lv_anim_t * a)
+{
+    trans_t * tr = a->var;
+
+    lv_part_t part = lv_obj_style_get_selector_part(tr->selector);
+    tr->start_value = lv_obj_get_style_prop(tr->obj, part, tr->prop);
+
+    /*Init prop to an invalid values to be sure `trans_del` won't delete this added `tr`*/
+    lv_style_prop_t prop_tmp = tr->prop;
+    tr->prop = LV_STYLE_PROP_INV;
+
+    /*Delete the related transitions if any*/
+    trans_delete(tr->obj, part, prop_tmp, tr);
+
+    tr->prop = prop_tmp;
+
+    lv_obj_style_t * style_trans = get_trans_style(tr->obj, tr->selector);
+    /*Be sure `trans_style` has a valid value*/
+    lv_style_set_prop((lv_style_t *)style_trans->style, tr->prop, tr->start_value);
+    lv_obj_refresh_style(tr->obj, tr->selector, tr->prop);
+
+}
+
+static void trans_anim_completed_cb(lv_anim_t * a)
+{
+    trans_t * tr = a->var;
+    lv_obj_t * obj = tr->obj;
+    lv_style_prop_t prop = tr->prop;
+
+    /*Remove the transitioned property from trans. style
+     *if there no more transitions for this property
+     *It allows changing it by normal styles*/
+    bool running = false;
+    trans_t * tr_i;
+    LV_LL_READ(style_trans_ll_p, tr_i) {
+        if(tr_i != tr && tr_i->obj == tr->obj && tr_i->selector == tr->selector && tr_i->prop == tr->prop) {
+            running = true;
+            break;
+        }
+    }
+
+    if(!running) {
+        uint32_t i;
+        for(i = 0; i < obj->style_cnt; i++) {
+            if(obj->styles[i].is_trans && obj->styles[i].selector == tr->selector) {
+                lv_ll_remove(style_trans_ll_p, tr);
+                lv_free(tr);
+
+                lv_obj_style_t * obj_style = &obj->styles[i];
+                lv_style_remove_prop((lv_style_t *)obj_style->style, prop);
+
+                if(lv_style_is_empty(obj->styles[i].style)) {
+                    lv_obj_remove_style(obj, (lv_style_t *)obj_style->style, obj_style->selector);
+
+                }
+                break;
+            }
+        }
+    }
+}
+
+static lv_layer_type_t calculate_layer_type(lv_obj_t * obj)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    if(lv_obj_get_transform(obj) != NULL) return LV_LAYER_TYPE_TRANSFORM;
+#endif
+    if(lv_obj_get_style_transform_rotation(obj, LV_PART_MAIN) != 0) return LV_LAYER_TYPE_TRANSFORM;
+    if(lv_obj_get_style_transform_scale_x(obj, LV_PART_MAIN) != 256) return LV_LAYER_TYPE_TRANSFORM;
+    if(lv_obj_get_style_transform_scale_y(obj, LV_PART_MAIN) != 256) return LV_LAYER_TYPE_TRANSFORM;
+    if(lv_obj_get_style_transform_skew_x(obj, LV_PART_MAIN) != 0) return LV_LAYER_TYPE_TRANSFORM;
+    if(lv_obj_get_style_transform_skew_y(obj, LV_PART_MAIN) != 0) return LV_LAYER_TYPE_TRANSFORM;
+    if(lv_obj_get_style_opa_layered(obj, LV_PART_MAIN) != LV_OPA_COVER) return LV_LAYER_TYPE_SIMPLE;
+    if(lv_obj_get_style_bitmap_mask_src(obj, LV_PART_MAIN) != NULL) return LV_LAYER_TYPE_SIMPLE;
+    if(lv_obj_get_style_blend_mode(obj, LV_PART_MAIN) != LV_BLEND_MODE_NORMAL) return LV_LAYER_TYPE_SIMPLE;
+    return LV_LAYER_TYPE_NONE;
+}
+
+static void full_cache_refresh(lv_obj_t * obj, lv_part_t part)
+{
+#if LV_OBJ_STYLE_CACHE
+    uint32_t i;
+    if(part == LV_PART_MAIN || part == LV_PART_ANY) {
+        obj->style_main_prop_is_set = 0;
+        for(i = 0; i < obj->style_cnt; i++) {
+            if(lv_obj_style_get_selector_part(obj->styles[i].selector) != LV_PART_MAIN) continue;
+            if(obj->styles[i].is_disabled) continue;
+            lv_style_t * style = (lv_style_t *)obj->styles[i].style;
+            uint32_t j;
+            if(lv_style_is_const(style)) {
+                lv_style_const_prop_t * props = style->values_and_props;
+                for(j = 0; props[j].prop != LV_STYLE_PROP_INV; j++) {
+                    obj->style_main_prop_is_set |= STYLE_PROP_SHIFTED(props[j].prop);
+                }
+            }
+            else {
+                lv_style_prop_t * props = (lv_style_prop_t *)style->values_and_props + style->prop_cnt * sizeof(lv_style_value_t);
+                for(j = 0; j < style->prop_cnt; j++) {
+                    obj->style_main_prop_is_set |= STYLE_PROP_SHIFTED(props[j]);
+                }
+            }
+        }
+    }
+    if(part != LV_PART_MAIN || part == LV_PART_ANY) {
+        obj->style_other_prop_is_set = 0;
+        for(i = 0; i < obj->style_cnt; i++) {
+            if(lv_obj_style_get_selector_part(obj->styles[i].selector) == LV_PART_MAIN) continue;
+            if(obj->styles[i].is_disabled) continue;
+
+            lv_style_t * style = (lv_style_t *)obj->styles[i].style;
+            uint32_t j;
+            if(lv_style_is_const(style)) {
+                lv_style_const_prop_t * props = style->values_and_props;
+                for(j = 0; props[j].prop != LV_STYLE_PROP_INV; j++) {
+                    obj->style_other_prop_is_set |= STYLE_PROP_SHIFTED(props[j].prop);
+                }
+            }
+            else {
+                lv_style_prop_t * props = (lv_style_prop_t *)style->values_and_props + style->prop_cnt * sizeof(lv_style_value_t);
+                for(j = 0; j < style->prop_cnt; j++) {
+                    obj->style_other_prop_is_set |= STYLE_PROP_SHIFTED(props[j]);
+                }
+            }
+        }
+    }
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(part);
+#endif
+}
+
+static void fade_anim_cb(void * obj, int32_t v)
+{
+    lv_obj_set_style_opa(obj, v, 0);
+}
+
+static void fade_in_anim_completed(lv_anim_t * a)
+{
+    lv_obj_remove_local_style_prop(a->var, LV_STYLE_OPA, 0);
+}
+
+static bool style_has_flag(const lv_style_t * style, uint32_t flag)
+{
+    if(lv_style_is_const(style)) {
+        lv_style_const_prop_t * props = style->values_and_props;
+        uint32_t i;
+        for(i = 0; props[i].prop != LV_STYLE_PROP_INV; i++) {
+            if(lv_style_prop_has_flag(props[i].prop, flag)) {
+                return true;
+            }
+        }
+    }
+    else {
+        lv_style_prop_t * props = (lv_style_prop_t *)style->values_and_props + style->prop_cnt * sizeof(lv_style_value_t);
+        uint32_t i;
+        for(i = 0; i < style->prop_cnt; i++) {
+            if(lv_style_prop_has_flag(props[i], flag)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static lv_style_res_t get_selector_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop,
+                                              lv_style_value_t * value_act)
+{
+    lv_style_res_t found;
+    lv_part_t part = lv_obj_style_get_selector_part(selector);
+
+    /*The happy path*/
+#if LV_OBJ_STYLE_CACHE
+    const uint32_t prop_shifted = STYLE_PROP_SHIFTED(prop);
+    if((part == LV_PART_MAIN ? obj->style_main_prop_is_set : obj->style_other_prop_is_set) & prop_shifted)
+#endif
+    {
+        found = get_prop_core(obj, selector, prop, value_act);
+        if(found == LV_STYLE_RES_FOUND) return LV_STYLE_RES_FOUND;
+    }
+
+    extern const uint8_t lv_style_builtin_prop_flag_lookup_table[];
+    bool inheritable = false;
+    if(prop < LV_STYLE_NUM_BUILT_IN_PROPS) {
+        inheritable = lv_style_builtin_prop_flag_lookup_table[prop] & LV_STYLE_PROP_FLAG_INHERITABLE;
+    }
+    else {
+        if(_style_custom_prop_flag_lookup_table != NULL) {
+            inheritable = _style_custom_prop_flag_lookup_table[prop - LV_STYLE_NUM_BUILT_IN_PROPS] &
+                          LV_STYLE_PROP_FLAG_INHERITABLE;
+        }
+    }
+
+    if(inheritable) {
+        /*If not found, check the `MAIN` style first, if already on the MAIN part go to the parent*/
+        if(part != LV_PART_MAIN) part = LV_PART_MAIN;
+        else obj = obj->parent;
+
+        while(obj) {
+#if LV_OBJ_STYLE_CACHE
+            if(obj->style_main_prop_is_set & prop_shifted)
+#endif
+            {
+                selector = part | obj->state;
+                found = get_prop_core(obj, selector, prop, value_act);
+                if(found == LV_STYLE_RES_FOUND) return LV_STYLE_RES_FOUND;
+            }
+            /*Check the parent too.*/
+            obj = obj->parent;
+        }
+    }
+    else {
+        /*Get the width and height from the class.
+                * WIDTH and HEIGHT are not inherited so add them in the `else` to skip checking them for inherited properties */
+        if(part == LV_PART_MAIN && (prop == LV_STYLE_WIDTH || prop == LV_STYLE_HEIGHT)) {
+            const lv_obj_class_t * cls = obj->class_p;
+            while(cls) {
+                if(prop == LV_STYLE_WIDTH) {
+                    if(cls->width_def != 0)  {
+                        value_act->num = cls->width_def;
+                        return LV_STYLE_RES_FOUND;
+                    }
+                }
+                else {
+                    if(cls->height_def != 0) {
+                        value_act->num = cls->height_def;
+                        return LV_STYLE_RES_FOUND;
+                    }
+                }
+                cls = cls->base_class;
+            }
+        }
+    }
+
+    return LV_STYLE_RES_NOT_FOUND;
+}

components/easylvgl/lvgl9/src/core/lv_obj_style.h

@@ -0,0 +1,405 @@
+/**
+ * @file lv_obj_style.h
+ *
+ */
+
+#ifndef LV_OBJ_STYLE_H
+#define LV_OBJ_STYLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_bidi.h"
+#include "../misc/lv_style.h"
+#include "../misc/lv_types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Possible states of a widget.
+ * OR-ed values are possible
+ */
+typedef enum {
+    LV_STATE_DEFAULT     = 0x0000,
+    LV_STATE_CHECKED     = 0x0001,
+    LV_STATE_FOCUSED     = 0x0002,
+    LV_STATE_FOCUS_KEY   = 0x0004,
+    LV_STATE_EDITED      = 0x0008,
+    LV_STATE_HOVERED     = 0x0010,
+    LV_STATE_PRESSED     = 0x0020,
+    LV_STATE_SCROLLED    = 0x0040,
+    LV_STATE_DISABLED    = 0x0080,
+    LV_STATE_USER_1      = 0x1000,
+    LV_STATE_USER_2      = 0x2000,
+    LV_STATE_USER_3      = 0x4000,
+    LV_STATE_USER_4      = 0x8000,
+
+    LV_STATE_ANY         = 0xFFFF,  /**< Special value can be used in some functions to target all states*/
+} lv_state_t;
+
+/**
+ * The possible parts of widgets.
+ * The parts can be considered as the internal building block of the widgets.
+ * E.g. slider = background + indicator + knob
+ * Not all parts are used by every widget
+ */
+
+typedef enum {
+    LV_PART_MAIN         = 0x000000,  /**< A background like rectangle*/
+    LV_PART_SCROLLBAR    = 0x010000,  /**< The scrollbar(s)*/
+    LV_PART_INDICATOR    = 0x020000,  /**< Indicator, e.g. for slider, bar, switch, or the tick box of the checkbox*/
+    LV_PART_KNOB         = 0x030000,  /**< Like handle to grab to adjust the value*/
+    LV_PART_SELECTED     = 0x040000,  /**< Indicate the currently selected option or section*/
+    LV_PART_ITEMS        = 0x050000,  /**< Used if the widget has multiple similar elements (e.g. table cells)*/
+    LV_PART_CURSOR       = 0x060000,  /**< Mark a specific place e.g. for text area's cursor or on a chart*/
+
+    LV_PART_CUSTOM_FIRST = 0x080000,  /**< Extension point for custom widgets*/
+
+    LV_PART_ANY          = 0x0F0000,  /**< Special value can be used in some functions to target all parts*/
+} lv_part_t;
+
+typedef enum {
+    LV_STYLE_STATE_CMP_SAME,           /**< The style properties in the 2 states are identical */
+    LV_STYLE_STATE_CMP_DIFF_REDRAW,    /**< The differences can be shown with a simple redraw */
+    LV_STYLE_STATE_CMP_DIFF_DRAW_PAD,  /**< The differences can be shown with a simple redraw */
+    LV_STYLE_STATE_CMP_DIFF_LAYOUT,    /**< The differences can be shown with a simple redraw */
+} lv_style_state_cmp_t;
+
+/**
+ * A joint type for `lv_part_t` and `lv_state_t`. Example values
+ * - `0`: means `LV_PART_MAIN | LV_STATE_DEFAULT`
+ * - `LV_STATE_PRSSED`
+ * - `LV_PART_KNOB`
+ * - `LV_PART_KNOB | LV_STATE_PRESSED | LV_STATE_CHECKED`
+ */
+typedef uint32_t lv_style_selector_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Add a style to an object.
+ * @param obj       pointer to an object
+ * @param style     pointer to a style to add
+ * @param selector  OR-ed value of parts and state to which the style should be added
+ *
+ * Examples:
+ * @code
+ * lv_obj_add_style(btn, &style_btn, 0); //Default button style
+ *
+ * lv_obj_add_style(btn, &btn_red, LV_STATE_PRESSED); //Overwrite only some colors to red when pressed
+ * @endcode
+ */
+void lv_obj_add_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector);
+
+/**
+ * Replaces a style of an object, preserving the order of the style stack (local styles and transitions are ignored).
+ * @param obj           pointer to an object
+ * @param old_style     pointer to a style to replace.
+ * @param new_style     pointer to a style to replace the old style with.
+ * @param selector      OR-ed values of states and a part to replace only styles with matching selectors. LV_STATE_ANY and LV_PART_ANY can be used
+ *
+ * Examples:
+ * @code
+ * lv_obj_replace_style(obj, &yellow_style, &blue_style, LV_PART_ANY | LV_STATE_ANY); //Replace a specific style
+ *
+ * lv_obj_replace_style(obj, &yellow_style, &blue_style, LV_PART_MAIN | LV_STATE_PRESSED); //Replace a specific style assigned to the main part when it is pressed
+ * @endcode
+ */
+bool lv_obj_replace_style(lv_obj_t * obj, const lv_style_t * old_style, const lv_style_t * new_style,
+                          lv_style_selector_t selector);
+
+/**
+ * Remove a style from an object.
+ * @param obj       pointer to an object
+ * @param style     pointer to a style to remove. Can be NULL to check only the selector
+ * @param selector  OR-ed values of states and a part to remove only styles with matching selectors. LV_STATE_ANY and LV_PART_ANY can be used
+ *
+ * Examples:
+ * @code
+ * lv_obj_remove_style(obj, &style, LV_PART_ANY | LV_STATE_ANY); //Remove a specific style
+ *
+ * lv_obj_remove_style(obj, NULL, LV_PART_MAIN | LV_STATE_ANY); //Remove all styles from the main part
+ *
+ * lv_obj_remove_style(obj, NULL, LV_PART_ANY | LV_STATE_ANY); //Remove all styles
+ * @endcode
+ */
+void lv_obj_remove_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector);
+
+/**
+ * Remove all styles from an object
+ * @param obj       pointer to an object
+ */
+void lv_obj_remove_style_all(lv_obj_t * obj);
+
+/**
+ * Notify all object if a style is modified
+ * @param style     pointer to a style. Only the objects with this style will be notified
+ *                  (NULL to notify all objects)
+ */
+void lv_obj_report_style_change(lv_style_t * style);
+
+/**
+ * Notify an object and its children about its style is modified.
+ * @param obj       pointer to an object
+ * @param part      the part whose style was changed. E.g. `LV_PART_ANY`, `LV_PART_MAIN`
+ * @param prop      `LV_STYLE_PROP_ANY` or an `LV_STYLE_...` property.
+ *                  It is used to optimize what needs to be refreshed.
+ *                  `LV_STYLE_PROP_INV` to perform only a style cache update
+ */
+void lv_obj_refresh_style(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop);
+
+/**
+ * Temporary disable a style for a selector. It will look like is the style wasn't added
+ * @param obj       pointer to an object
+ * @param style     pointer to a style
+ * @param selector  the selector of a style (e.g. LV_STATE_PRESSED | LV_PART_KNOB)
+ * @param dis       true: disable the style, false: enable the style
+ */
+void lv_obj_style_set_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector, bool dis);
+
+/**
+ * Get if a given style is disabled on an object.
+ * @param obj       pointer to an object
+ * @param style     pointer to a style
+ * @param selector  the selector of a style (e.g. LV_STATE_PRESSED | LV_PART_KNOB)
+ * @return          true: disable the style, false: enable the style
+ */
+bool lv_obj_style_get_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector);
+
+/**
+ * Enable or disable automatic style refreshing when a new style is added/removed to/from an object
+ * or any other style change happens.
+ * @param en        true: enable refreshing; false: disable refreshing
+ */
+void lv_obj_enable_style_refresh(bool en);
+
+/**
+ * Get the value of a style property. The current state of the object will be considered.
+ * Inherited properties will be inherited.
+ * If a property is not set a default value will be returned.
+ * @param obj       pointer to an object
+ * @param part      a part from which the property should be get
+ * @param prop      the property to get
+ * @return          the value of the property.
+ *                  Should be read from the correct field of the `lv_style_value_t` according to the type of the property.
+ */
+lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop);
+
+/**
+ * Check if an object has a specified style property for a given style selector.
+ * @param obj       pointer to an object
+ * @param selector  the style selector to be checked, defining the scope of the style to be examined.
+ * @param prop      the property to be checked.
+ * @return          true if the object has the specified selector and property, false otherwise.
+ */
+bool lv_obj_has_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop);
+
+/**
+ * Set local style property on an object's part and state.
+ * @param obj       pointer to an object
+ * @param prop      the property
+ * @param value     value of the property. The correct element should be set according to the type of the property
+ * @param selector  OR-ed value of parts and state for which the style should be set
+ */
+void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value,
+                                 lv_style_selector_t selector);
+
+lv_style_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value,
+                                           lv_style_selector_t selector);
+
+/**
+ * Remove a local style property from a part of an object with a given state.
+ * @param obj       pointer to an object
+ * @param prop      a style property to remove.
+ * @param selector  OR-ed value of parts and state for which the style should be removed
+ * @return true     the property was found and removed; false: the property was not found
+ */
+bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_selector_t selector);
+
+/**
+ * Used internally for color filtering
+ */
+lv_style_value_t lv_obj_style_apply_color_filter(const lv_obj_t * obj, lv_part_t part, lv_style_value_t v);
+
+/**
+ * Fade in an an object and all its children.
+ * @param obj       the object to fade in
+ * @param time      time of fade
+ * @param delay     delay to start the animation
+ */
+void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay);
+
+/**
+ * Fade out an an object and all its children.
+ * @param obj       the object to fade out
+ * @param time      time of fade
+ * @param delay     delay to start the animation
+ */
+void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
+
+static inline lv_state_t lv_obj_style_get_selector_state(lv_style_selector_t selector)
+{
+    return (lv_state_t)(selector & 0xFFFF);
+}
+
+static inline lv_part_t lv_obj_style_get_selector_part(lv_style_selector_t selector)
+{
+    return (lv_part_t)(selector & 0xFF0000);
+}
+
+#include "lv_obj_style_gen.h"
+
+static inline void lv_obj_set_style_pad_all(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_pad_left(obj, value, selector);
+    lv_obj_set_style_pad_right(obj, value, selector);
+    lv_obj_set_style_pad_top(obj, value, selector);
+    lv_obj_set_style_pad_bottom(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_pad_hor(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_pad_left(obj, value, selector);
+    lv_obj_set_style_pad_right(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_pad_ver(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_pad_top(obj, value, selector);
+    lv_obj_set_style_pad_bottom(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_margin_all(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_margin_left(obj, value, selector);
+    lv_obj_set_style_margin_right(obj, value, selector);
+    lv_obj_set_style_margin_top(obj, value, selector);
+    lv_obj_set_style_margin_bottom(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_margin_hor(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_margin_left(obj, value, selector);
+    lv_obj_set_style_margin_right(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_margin_ver(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_margin_top(obj, value, selector);
+    lv_obj_set_style_margin_bottom(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_pad_gap(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_obj_set_style_pad_row(obj, value, selector);
+    lv_obj_set_style_pad_column(obj, value, selector);
+}
+
+static inline void lv_obj_set_style_size(lv_obj_t * obj, int32_t width, int32_t height,
+                                         lv_style_selector_t selector)
+{
+    lv_obj_set_style_width(obj, width, selector);
+    lv_obj_set_style_height(obj, height, selector);
+}
+
+static inline void lv_obj_set_style_transform_scale(lv_obj_t * obj, int32_t value,
+                                                    lv_style_selector_t selector)
+{
+    lv_obj_set_style_transform_scale_x(obj, value, selector);
+    lv_obj_set_style_transform_scale_y(obj, value, selector);
+}
+
+static inline int32_t lv_obj_get_style_space_left(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t padding = lv_obj_get_style_pad_left(obj, part);
+    int32_t border_width = lv_obj_get_style_border_width(obj, part);
+    lv_border_side_t border_side = lv_obj_get_style_border_side(obj, part);
+    return (border_side & LV_BORDER_SIDE_LEFT) ? padding + border_width : padding;
+}
+
+static inline int32_t lv_obj_get_style_space_right(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t padding = lv_obj_get_style_pad_right(obj, part);
+    int32_t border_width = lv_obj_get_style_border_width(obj, part);
+    lv_border_side_t border_side = lv_obj_get_style_border_side(obj, part);
+    return (border_side & LV_BORDER_SIDE_RIGHT) ? padding + border_width : padding;
+}
+
+static inline int32_t lv_obj_get_style_space_top(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t padding = lv_obj_get_style_pad_top(obj, part);
+    int32_t border_width = lv_obj_get_style_border_width(obj, part);
+    lv_border_side_t border_side = lv_obj_get_style_border_side(obj, part);
+    return (border_side & LV_BORDER_SIDE_TOP) ? padding + border_width : padding;
+}
+
+static inline int32_t lv_obj_get_style_space_bottom(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t padding = lv_obj_get_style_pad_bottom(obj, part);
+    int32_t border_width = lv_obj_get_style_border_width(obj, part);
+    lv_border_side_t border_side = lv_obj_get_style_border_side(obj, part);
+    return (border_side & LV_BORDER_SIDE_BOTTOM) ? padding + border_width : padding;
+}
+
+lv_text_align_t lv_obj_calculate_style_text_align(const lv_obj_t * obj, lv_part_t part, const char * txt);
+
+static inline int32_t lv_obj_get_style_transform_scale_x_safe(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t scale = lv_obj_get_style_transform_scale_x(obj, part);
+    return scale > 0 ? scale : 1;
+}
+
+static inline int32_t lv_obj_get_style_transform_scale_y_safe(const lv_obj_t * obj, lv_part_t part)
+{
+    int32_t scale = lv_obj_get_style_transform_scale_y(obj, part);
+    return scale > 0 ? scale : 1;
+}
+
+/**
+ * Get the `opa` style property from all parents and multiply and `>> 8` them.
+ * @param obj       the object whose opacity should be get
+ * @param part      the part whose opacity should be get. Non-MAIN parts will consider the `opa` of the MAIN part too
+ * @return          the final opacity considering the parents' opacity too
+ */
+lv_opa_t lv_obj_get_style_opa_recursive(const lv_obj_t * obj, lv_part_t part);
+
+
+/**
+ * Apply recolor effect to the input color based on the object's style properties.
+ * @param obj       the target object containing recolor style properties
+ * @param part      the part to retrieve recolor styles.
+ * @param color     the original color to be modified
+ * @return          the blended color after applying recolor and opacity
+ */
+lv_color32_t lv_obj_style_apply_recolor(const lv_obj_t * obj, lv_part_t part, lv_color32_t color);
+
+/**
+ * Get the `recolor` style property from all parents and blend them recursively.
+ * @param obj       the object whose recolor value should be retrieved
+ * @param part      the target part to check. Non-MAIN parts will also consider
+ *                  the `recolor` value from the MAIN part during calculation
+ * @return          the final blended recolor value combining all parent's recolor values
+ */
+lv_color32_t lv_obj_get_style_recolor_recursive(const lv_obj_t * obj, lv_part_t part);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_STYLE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_style_gen.c

@@ -0,0 +1,969 @@
+
+/*
+ **********************************************************************
+ *                            DO NOT EDIT
+ * This file is automatically generated by "style_api_gen.py"
+ **********************************************************************
+ */
+
+
+#include "lv_obj.h"
+
+
+void lv_obj_set_style_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_min_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MIN_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_max_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MAX_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_HEIGHT, v, selector);
+}
+
+void lv_obj_set_style_min_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MIN_HEIGHT, v, selector);
+}
+
+void lv_obj_set_style_max_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MAX_HEIGHT, v, selector);
+}
+
+void lv_obj_set_style_length(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LENGTH, v, selector);
+}
+
+void lv_obj_set_style_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_X, v, selector);
+}
+
+void lv_obj_set_style_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_Y, v, selector);
+}
+
+void lv_obj_set_style_align(lv_obj_t * obj, lv_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_transform_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_transform_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_HEIGHT, v, selector);
+}
+
+void lv_obj_set_style_translate_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSLATE_X, v, selector);
+}
+
+void lv_obj_set_style_translate_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSLATE_Y, v, selector);
+}
+
+void lv_obj_set_style_translate_radial(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSLATE_RADIAL, v, selector);
+}
+
+void lv_obj_set_style_transform_scale_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_SCALE_X, v, selector);
+}
+
+void lv_obj_set_style_transform_scale_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_SCALE_Y, v, selector);
+}
+
+void lv_obj_set_style_transform_rotation(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_ROTATION, v, selector);
+}
+
+void lv_obj_set_style_transform_pivot_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_PIVOT_X, v, selector);
+}
+
+void lv_obj_set_style_transform_pivot_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_PIVOT_Y, v, selector);
+}
+
+void lv_obj_set_style_transform_skew_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_SKEW_X, v, selector);
+}
+
+void lv_obj_set_style_transform_skew_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_SKEW_Y, v, selector);
+}
+
+void lv_obj_set_style_pad_top(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_TOP, v, selector);
+}
+
+void lv_obj_set_style_pad_bottom(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_BOTTOM, v, selector);
+}
+
+void lv_obj_set_style_pad_left(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_LEFT, v, selector);
+}
+
+void lv_obj_set_style_pad_right(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_RIGHT, v, selector);
+}
+
+void lv_obj_set_style_pad_row(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_ROW, v, selector);
+}
+
+void lv_obj_set_style_pad_column(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_COLUMN, v, selector);
+}
+
+void lv_obj_set_style_pad_radial(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_PAD_RADIAL, v, selector);
+}
+
+void lv_obj_set_style_margin_top(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MARGIN_TOP, v, selector);
+}
+
+void lv_obj_set_style_margin_bottom(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MARGIN_BOTTOM, v, selector);
+}
+
+void lv_obj_set_style_margin_left(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MARGIN_LEFT, v, selector);
+}
+
+void lv_obj_set_style_margin_right(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_MARGIN_RIGHT, v, selector);
+}
+
+void lv_obj_set_style_bg_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_COLOR, v, selector);
+}
+
+void lv_obj_set_style_bg_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_OPA, v, selector);
+}
+
+void lv_obj_set_style_bg_grad_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_GRAD_COLOR, v, selector);
+}
+
+void lv_obj_set_style_bg_grad_dir(lv_obj_t * obj, lv_grad_dir_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_GRAD_DIR, v, selector);
+}
+
+void lv_obj_set_style_bg_main_stop(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_MAIN_STOP, v, selector);
+}
+
+void lv_obj_set_style_bg_grad_stop(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_GRAD_STOP, v, selector);
+}
+
+void lv_obj_set_style_bg_main_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_MAIN_OPA, v, selector);
+}
+
+void lv_obj_set_style_bg_grad_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_GRAD_OPA, v, selector);
+}
+
+void lv_obj_set_style_bg_grad(lv_obj_t * obj, const lv_grad_dsc_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_GRAD, v, selector);
+}
+
+void lv_obj_set_style_bg_image_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_IMAGE_SRC, v, selector);
+}
+
+void lv_obj_set_style_bg_image_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_IMAGE_OPA, v, selector);
+}
+
+void lv_obj_set_style_bg_image_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_IMAGE_RECOLOR, v, selector);
+}
+
+void lv_obj_set_style_bg_image_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_IMAGE_RECOLOR_OPA, v, selector);
+}
+
+void lv_obj_set_style_bg_image_tiled(lv_obj_t * obj, bool value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BG_IMAGE_TILED, v, selector);
+}
+
+void lv_obj_set_style_border_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BORDER_COLOR, v, selector);
+}
+
+void lv_obj_set_style_border_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BORDER_OPA, v, selector);
+}
+
+void lv_obj_set_style_border_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BORDER_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_border_side(lv_obj_t * obj, lv_border_side_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BORDER_SIDE, v, selector);
+}
+
+void lv_obj_set_style_border_post(lv_obj_t * obj, bool value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BORDER_POST, v, selector);
+}
+
+void lv_obj_set_style_outline_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OUTLINE_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_outline_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OUTLINE_COLOR, v, selector);
+}
+
+void lv_obj_set_style_outline_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OUTLINE_OPA, v, selector);
+}
+
+void lv_obj_set_style_outline_pad(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OUTLINE_PAD, v, selector);
+}
+
+void lv_obj_set_style_shadow_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_shadow_offset_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_OFFSET_X, v, selector);
+}
+
+void lv_obj_set_style_shadow_offset_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_OFFSET_Y, v, selector);
+}
+
+void lv_obj_set_style_shadow_spread(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_SPREAD, v, selector);
+}
+
+void lv_obj_set_style_shadow_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_COLOR, v, selector);
+}
+
+void lv_obj_set_style_shadow_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_SHADOW_OPA, v, selector);
+}
+
+void lv_obj_set_style_image_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_IMAGE_OPA, v, selector);
+}
+
+void lv_obj_set_style_image_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_IMAGE_RECOLOR, v, selector);
+}
+
+void lv_obj_set_style_image_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_IMAGE_RECOLOR_OPA, v, selector);
+}
+
+void lv_obj_set_style_image_colorkey(lv_obj_t * obj, const lv_image_colorkey_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_IMAGE_COLORKEY, v, selector);
+}
+
+void lv_obj_set_style_line_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_line_dash_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_DASH_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_line_dash_gap(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_DASH_GAP, v, selector);
+}
+
+void lv_obj_set_style_line_rounded(lv_obj_t * obj, bool value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_ROUNDED, v, selector);
+}
+
+void lv_obj_set_style_line_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_COLOR, v, selector);
+}
+
+void lv_obj_set_style_line_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_OPA, v, selector);
+}
+
+void lv_obj_set_style_arc_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_arc_rounded(lv_obj_t * obj, bool value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_ROUNDED, v, selector);
+}
+
+void lv_obj_set_style_arc_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_COLOR, v, selector);
+}
+
+void lv_obj_set_style_arc_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_OPA, v, selector);
+}
+
+void lv_obj_set_style_arc_image_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_IMAGE_SRC, v, selector);
+}
+
+void lv_obj_set_style_text_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_COLOR, v, selector);
+}
+
+void lv_obj_set_style_text_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_OPA, v, selector);
+}
+
+void lv_obj_set_style_text_font(lv_obj_t * obj, const lv_font_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_FONT, v, selector);
+}
+
+void lv_obj_set_style_text_letter_space(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_LETTER_SPACE, v, selector);
+}
+
+void lv_obj_set_style_text_line_space(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_LINE_SPACE, v, selector);
+}
+
+void lv_obj_set_style_text_decor(lv_obj_t * obj, lv_text_decor_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_DECOR, v, selector);
+}
+
+void lv_obj_set_style_text_align(lv_obj_t * obj, lv_text_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_text_outline_stroke_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_OUTLINE_STROKE_COLOR, v, selector);
+}
+
+void lv_obj_set_style_text_outline_stroke_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_OUTLINE_STROKE_WIDTH, v, selector);
+}
+
+void lv_obj_set_style_text_outline_stroke_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TEXT_OUTLINE_STROKE_OPA, v, selector);
+}
+
+void lv_obj_set_style_radius(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_RADIUS, v, selector);
+}
+
+void lv_obj_set_style_radial_offset(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_RADIAL_OFFSET, v, selector);
+}
+
+void lv_obj_set_style_clip_corner(lv_obj_t * obj, bool value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_CLIP_CORNER, v, selector);
+}
+
+void lv_obj_set_style_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OPA, v, selector);
+}
+
+void lv_obj_set_style_opa_layered(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_OPA_LAYERED, v, selector);
+}
+
+void lv_obj_set_style_color_filter_dsc(lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_COLOR_FILTER_DSC, v, selector);
+}
+
+void lv_obj_set_style_color_filter_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_COLOR_FILTER_OPA, v, selector);
+}
+
+void lv_obj_set_style_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .color = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_RECOLOR, v, selector);
+}
+
+void lv_obj_set_style_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_RECOLOR_OPA, v, selector);
+}
+
+void lv_obj_set_style_anim(lv_obj_t * obj, const lv_anim_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ANIM, v, selector);
+}
+
+void lv_obj_set_style_anim_duration(lv_obj_t * obj, uint32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ANIM_DURATION, v, selector);
+}
+
+void lv_obj_set_style_transition(lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSITION, v, selector);
+}
+
+void lv_obj_set_style_blend_mode(lv_obj_t * obj, lv_blend_mode_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BLEND_MODE, v, selector);
+}
+
+void lv_obj_set_style_layout(lv_obj_t * obj, uint16_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_LAYOUT, v, selector);
+}
+
+void lv_obj_set_style_base_dir(lv_obj_t * obj, lv_base_dir_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BASE_DIR, v, selector);
+}
+
+void lv_obj_set_style_bitmap_mask_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_BITMAP_MASK_SRC, v, selector);
+}
+
+void lv_obj_set_style_rotary_sensitivity(lv_obj_t * obj, uint32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_ROTARY_SENSITIVITY, v, selector);
+}
+#if LV_USE_FLEX
+
+void lv_obj_set_style_flex_flow(lv_obj_t * obj, lv_flex_flow_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_FLEX_FLOW, v, selector);
+}
+
+void lv_obj_set_style_flex_main_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_FLEX_MAIN_PLACE, v, selector);
+}
+
+void lv_obj_set_style_flex_cross_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_FLEX_CROSS_PLACE, v, selector);
+}
+
+void lv_obj_set_style_flex_track_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_FLEX_TRACK_PLACE, v, selector);
+}
+
+void lv_obj_set_style_flex_grow(lv_obj_t * obj, uint8_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_FLEX_GROW, v, selector);
+}
+#endif /*LV_USE_FLEX*/
+
+#if LV_USE_GRID
+
+void lv_obj_set_style_grid_column_dsc_array(lv_obj_t * obj, const int32_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_COLUMN_DSC_ARRAY, v, selector);
+}
+
+void lv_obj_set_style_grid_column_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_COLUMN_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_grid_row_dsc_array(lv_obj_t * obj, const int32_t * value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .ptr = value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_ROW_DSC_ARRAY, v, selector);
+}
+
+void lv_obj_set_style_grid_row_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_ROW_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_column_pos(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_COLUMN_POS, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_x_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_X_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_column_span(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_COLUMN_SPAN, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_row_pos(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_ROW_POS, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_y_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_Y_ALIGN, v, selector);
+}
+
+void lv_obj_set_style_grid_cell_row_span(lv_obj_t * obj, int32_t value, lv_style_selector_t selector)
+{
+    lv_style_value_t v = {
+        .num = (int32_t)value
+    };
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_ROW_SPAN, v, selector);
+}
+#endif /*LV_USE_GRID*/
+

components/easylvgl/lvgl9/src/core/lv_obj_style_gen.h

@@ -0,0 +1,938 @@
+
+/*
+ **********************************************************************
+ *                            DO NOT EDIT
+ * This file is automatically generated by "style_api_gen.py"
+ **********************************************************************
+ */
+
+
+#ifndef LV_OBJ_STYLE_GEN_H
+#define LV_OBJ_STYLE_GEN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../misc/lv_area.h"
+#include "../misc/lv_style.h"
+#include "../core/lv_obj_style.h"
+#include "../misc/lv_types.h"
+
+static inline int32_t lv_obj_get_style_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_min_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MIN_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_max_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MAX_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_height(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_HEIGHT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_min_height(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MIN_HEIGHT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_max_height(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MAX_HEIGHT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_length(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LENGTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_Y);
+    return (int32_t)v.num;
+}
+
+static inline lv_align_t lv_obj_get_style_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ALIGN);
+    return (lv_align_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_height(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_HEIGHT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_translate_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSLATE_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_translate_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSLATE_Y);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_translate_radial(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSLATE_RADIAL);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_scale_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_SCALE_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_scale_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_SCALE_Y);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_rotation(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_ROTATION);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_pivot_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_PIVOT_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_pivot_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_PIVOT_Y);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_skew_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_SKEW_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_transform_skew_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_SKEW_Y);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_top(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_TOP);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_bottom(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_BOTTOM);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_left(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_LEFT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_right(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_RIGHT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_row(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_ROW);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_column(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_COLUMN);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_pad_radial(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_PAD_RADIAL);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_margin_top(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MARGIN_TOP);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_margin_bottom(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MARGIN_BOTTOM);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_margin_left(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MARGIN_LEFT);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_margin_right(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_MARGIN_RIGHT);
+    return (int32_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_color_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_COLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_bg_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_grad_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_grad_color_filtered(const lv_obj_t * obj, lv_part_t 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));
+    return v.color;
+}
+
+static inline lv_grad_dir_t lv_obj_get_style_bg_grad_dir(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_DIR);
+    return (lv_grad_dir_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_bg_main_stop(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_MAIN_STOP);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_bg_grad_stop(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_STOP);
+    return (int32_t)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_bg_main_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_MAIN_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_bg_grad_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline const lv_grad_dsc_t * lv_obj_get_style_bg_grad(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD);
+    return (const lv_grad_dsc_t *)v.ptr;
+}
+
+static inline const void * lv_obj_get_style_bg_image_src(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_SRC);
+    return (const void *)v.ptr;
+}
+
+static inline lv_opa_t lv_obj_get_style_bg_image_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_image_recolor(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_RECOLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_bg_image_recolor_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_RECOLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_bg_image_recolor_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_RECOLOR_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline bool lv_obj_get_style_bg_image_tiled(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMAGE_TILED);
+    return (bool)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_border_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_border_color_filtered(const lv_obj_t * obj, lv_part_t 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));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_border_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_border_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline lv_border_side_t lv_obj_get_style_border_side(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_SIDE);
+    return (lv_border_side_t)v.num;
+}
+
+static inline bool lv_obj_get_style_border_post(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_POST);
+    return (bool)v.num;
+}
+
+static inline int32_t lv_obj_get_style_outline_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_outline_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_outline_color_filtered(const lv_obj_t * obj, lv_part_t 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));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_outline_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_outline_pad(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_PAD);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_shadow_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_shadow_offset_x(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_OFFSET_X);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_shadow_offset_y(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_OFFSET_Y);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_shadow_spread(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_SPREAD);
+    return (int32_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_shadow_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_shadow_color_filtered(const lv_obj_t * obj, lv_part_t 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));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_shadow_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_image_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_IMAGE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_image_recolor(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_IMAGE_RECOLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_image_recolor_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_IMAGE_RECOLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_image_recolor_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_IMAGE_RECOLOR_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline const lv_image_colorkey_t * lv_obj_get_style_image_colorkey(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_IMAGE_COLORKEY);
+    return (const lv_image_colorkey_t *)v.ptr;
+}
+
+static inline int32_t lv_obj_get_style_line_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_line_dash_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_DASH_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_line_dash_gap(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_DASH_GAP);
+    return (int32_t)v.num;
+}
+
+static inline bool lv_obj_get_style_line_rounded(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_ROUNDED);
+    return (bool)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_line_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_line_color_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_COLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_line_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_arc_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline bool lv_obj_get_style_arc_rounded(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_ROUNDED);
+    return (bool)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_arc_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_arc_color_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_COLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_arc_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline const void * lv_obj_get_style_arc_image_src(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_IMAGE_SRC);
+    return (const void *)v.ptr;
+}
+
+static inline lv_color_t lv_obj_get_style_text_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_text_color_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_COLOR));
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_text_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline const lv_font_t * lv_obj_get_style_text_font(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_FONT);
+    return (const lv_font_t *)v.ptr;
+}
+
+static inline int32_t lv_obj_get_style_text_letter_space(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_LETTER_SPACE);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_text_line_space(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_LINE_SPACE);
+    return (int32_t)v.num;
+}
+
+static inline lv_text_decor_t lv_obj_get_style_text_decor(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_DECOR);
+    return (lv_text_decor_t)v.num;
+}
+
+static inline lv_text_align_t lv_obj_get_style_text_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_ALIGN);
+    return (lv_text_align_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_text_outline_stroke_color(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_OUTLINE_STROKE_COLOR);
+    return v.color;
+}
+
+static inline lv_color_t lv_obj_get_style_text_outline_stroke_color_filtered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_OUTLINE_STROKE_COLOR));
+    return v.color;
+}
+
+static inline int32_t lv_obj_get_style_text_outline_stroke_width(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_OUTLINE_STROKE_WIDTH);
+    return (int32_t)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_text_outline_stroke_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TEXT_OUTLINE_STROKE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_radius(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_RADIUS);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_radial_offset(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_RADIAL_OFFSET);
+    return (int32_t)v.num;
+}
+
+static inline bool lv_obj_get_style_clip_corner(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_CLIP_CORNER);
+    return (bool)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_opa_t lv_obj_get_style_opa_layered(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_OPA_LAYERED);
+    return (lv_opa_t)v.num;
+}
+
+static inline const lv_color_filter_dsc_t * lv_obj_get_style_color_filter_dsc(const lv_obj_t * obj, lv_part_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;
+}
+
+static inline lv_opa_t lv_obj_get_style_color_filter_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_COLOR_FILTER_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline lv_color_t lv_obj_get_style_recolor(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_RECOLOR);
+    return v.color;
+}
+
+static inline lv_opa_t lv_obj_get_style_recolor_opa(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_RECOLOR_OPA);
+    return (lv_opa_t)v.num;
+}
+
+static inline const lv_anim_t * lv_obj_get_style_anim(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ANIM);
+    return (const lv_anim_t *)v.ptr;
+}
+
+static inline uint32_t lv_obj_get_style_anim_duration(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ANIM_DURATION);
+    return (uint32_t)v.num;
+}
+
+static inline const lv_style_transition_dsc_t * lv_obj_get_style_transition(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSITION);
+    return (const lv_style_transition_dsc_t *)v.ptr;
+}
+
+static inline lv_blend_mode_t lv_obj_get_style_blend_mode(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BLEND_MODE);
+    return (lv_blend_mode_t)v.num;
+}
+
+static inline uint16_t lv_obj_get_style_layout(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LAYOUT);
+    return (uint16_t)v.num;
+}
+
+static inline lv_base_dir_t lv_obj_get_style_base_dir(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BASE_DIR);
+    return (lv_base_dir_t)v.num;
+}
+
+static inline const void * lv_obj_get_style_bitmap_mask_src(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_BITMAP_MASK_SRC);
+    return (const void *)v.ptr;
+}
+
+static inline uint32_t lv_obj_get_style_rotary_sensitivity(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ROTARY_SENSITIVITY);
+    return (uint32_t)v.num;
+}
+
+#if LV_USE_FLEX
+static inline lv_flex_flow_t lv_obj_get_style_flex_flow(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_FLOW);
+    return (lv_flex_flow_t)v.num;
+}
+
+static inline lv_flex_align_t lv_obj_get_style_flex_main_place(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_MAIN_PLACE);
+    return (lv_flex_align_t)v.num;
+}
+
+static inline lv_flex_align_t lv_obj_get_style_flex_cross_place(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_CROSS_PLACE);
+    return (lv_flex_align_t)v.num;
+}
+
+static inline lv_flex_align_t lv_obj_get_style_flex_track_place(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_TRACK_PLACE);
+    return (lv_flex_align_t)v.num;
+}
+
+static inline uint8_t lv_obj_get_style_flex_grow(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_GROW);
+    return (uint8_t)v.num;
+}
+
+#endif /*LV_USE_FLEX*/
+
+#if LV_USE_GRID
+static inline const int32_t * lv_obj_get_style_grid_column_dsc_array(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_COLUMN_DSC_ARRAY);
+    return (const int32_t *)v.ptr;
+}
+
+static inline lv_grid_align_t lv_obj_get_style_grid_column_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_COLUMN_ALIGN);
+    return (lv_grid_align_t)v.num;
+}
+
+static inline const int32_t * lv_obj_get_style_grid_row_dsc_array(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_ROW_DSC_ARRAY);
+    return (const int32_t *)v.ptr;
+}
+
+static inline lv_grid_align_t lv_obj_get_style_grid_row_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_ROW_ALIGN);
+    return (lv_grid_align_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_grid_cell_column_pos(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_COLUMN_POS);
+    return (int32_t)v.num;
+}
+
+static inline lv_grid_align_t lv_obj_get_style_grid_cell_x_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_X_ALIGN);
+    return (lv_grid_align_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_grid_cell_column_span(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_COLUMN_SPAN);
+    return (int32_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_grid_cell_row_pos(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_ROW_POS);
+    return (int32_t)v.num;
+}
+
+static inline lv_grid_align_t lv_obj_get_style_grid_cell_y_align(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_Y_ALIGN);
+    return (lv_grid_align_t)v.num;
+}
+
+static inline int32_t lv_obj_get_style_grid_cell_row_span(const lv_obj_t * obj, lv_part_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_ROW_SPAN);
+    return (int32_t)v.num;
+}
+
+#endif /*LV_USE_GRID*/
+
+void lv_obj_set_style_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_min_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_max_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_min_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_max_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_length(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_align(lv_obj_t * obj, lv_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_height(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_translate_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_translate_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_translate_radial(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_scale_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_scale_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_rotation(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_pivot_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_pivot_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_skew_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transform_skew_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_top(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_bottom(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_left(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_right(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_row(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_column(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_pad_radial(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_margin_top(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_margin_bottom(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_margin_left(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_margin_right(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_grad_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_grad_dir(lv_obj_t * obj, lv_grad_dir_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_main_stop(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_grad_stop(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_main_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_grad_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_grad(lv_obj_t * obj, const lv_grad_dsc_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_image_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_image_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_image_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_image_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bg_image_tiled(lv_obj_t * obj, bool value, lv_style_selector_t selector);
+void lv_obj_set_style_border_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_border_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_border_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_border_side(lv_obj_t * obj, lv_border_side_t value, lv_style_selector_t selector);
+void lv_obj_set_style_border_post(lv_obj_t * obj, bool value, lv_style_selector_t selector);
+void lv_obj_set_style_outline_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_outline_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_outline_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_outline_pad(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_offset_x(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_offset_y(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_spread(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_shadow_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_image_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_image_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_image_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_image_colorkey(lv_obj_t * obj, const lv_image_colorkey_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_line_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_line_dash_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_line_dash_gap(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_line_rounded(lv_obj_t * obj, bool value, lv_style_selector_t selector);
+void lv_obj_set_style_line_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_line_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_rounded(lv_obj_t * obj, bool value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_image_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector);
+void lv_obj_set_style_text_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_font(lv_obj_t * obj, const lv_font_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_text_letter_space(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_line_space(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_decor(lv_obj_t * obj, lv_text_decor_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_align(lv_obj_t * obj, lv_text_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_outline_stroke_color(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_outline_stroke_width(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_text_outline_stroke_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_radius(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_radial_offset(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_clip_corner(lv_obj_t * obj, bool value, lv_style_selector_t selector);
+void lv_obj_set_style_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_opa_layered(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_color_filter_dsc(lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_color_filter_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_recolor(lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
+void lv_obj_set_style_recolor_opa(lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
+void lv_obj_set_style_anim(lv_obj_t * obj, const lv_anim_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_anim_duration(lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_transition(lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_blend_mode(lv_obj_t * obj, lv_blend_mode_t value, lv_style_selector_t selector);
+void lv_obj_set_style_layout(lv_obj_t * obj, uint16_t value, lv_style_selector_t selector);
+void lv_obj_set_style_base_dir(lv_obj_t * obj, lv_base_dir_t value, lv_style_selector_t selector);
+void lv_obj_set_style_bitmap_mask_src(lv_obj_t * obj, const void * value, lv_style_selector_t selector);
+void lv_obj_set_style_rotary_sensitivity(lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
+#if LV_USE_FLEX
+void lv_obj_set_style_flex_flow(lv_obj_t * obj, lv_flex_flow_t value, lv_style_selector_t selector);
+void lv_obj_set_style_flex_main_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_flex_cross_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_flex_track_place(lv_obj_t * obj, lv_flex_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_flex_grow(lv_obj_t * obj, uint8_t value, lv_style_selector_t selector);
+#endif /*LV_USE_FLEX*/
+
+#if LV_USE_GRID
+void lv_obj_set_style_grid_column_dsc_array(lv_obj_t * obj, const int32_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_column_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_row_dsc_array(lv_obj_t * obj, const int32_t * value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_row_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_column_pos(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_x_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_column_span(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_row_pos(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_y_align(lv_obj_t * obj, lv_grid_align_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_row_span(lv_obj_t * obj, int32_t value, lv_style_selector_t selector);
+#endif /*LV_USE_GRID*/
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV_OBJ_STYLE_GEN_H */

components/easylvgl/lvgl9/src/core/lv_obj_style_private.h

@@ -0,0 +1,96 @@
+/**
+ * @file lv_obj_style_private.h
+ *
+ */
+
+#ifndef LV_OBJ_STYLE_PRIVATE_H
+#define LV_OBJ_STYLE_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_obj_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_obj_style_t {
+    const lv_style_t * style;
+    uint32_t selector : 24;
+    uint32_t is_local : 1;
+    uint32_t is_trans : 1;
+    uint32_t is_disabled : 1;
+};
+
+struct _lv_obj_style_transition_dsc_t {
+    uint16_t time;
+    uint16_t delay;
+    lv_style_selector_t selector;
+    lv_style_prop_t prop;
+    lv_anim_path_cb_t path_cb;
+    void * user_data;
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the object related style manager module.
+ * Called by LVGL in `lv_init()`
+ */
+void lv_obj_style_init(void);
+
+/**
+ * Deinitialize the object related style manager module.
+ * Called by LVGL in `lv_deinit()`
+ */
+void lv_obj_style_deinit(void);
+
+/**
+ * Used internally to create a style transition
+ * @param obj
+ * @param part
+ * @param prev_state
+ * @param new_state
+ * @param tr
+ */
+void lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t prev_state,
+                                    lv_state_t new_state, const lv_obj_style_transition_dsc_t * tr);
+
+/**
+ * Used internally to compare the appearance of an object in 2 states
+ * @param obj
+ * @param state1
+ * @param state2
+ * @return
+ */
+lv_style_state_cmp_t lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t state1, lv_state_t state2);
+
+/**
+ * Update the layer type of a widget bayed on its current styles.
+ * The result will be stored in `obj->spec_attr->layer_type`
+ * @param obj       the object whose layer should be updated
+ */
+void lv_obj_update_layer_type(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_STYLE_PRIVATE_H*/

components/easylvgl/lvgl9/src/core/lv_obj_tree.c

@@ -0,0 +1,845 @@
+/**
+ * @file lv_obj_tree.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_private.h"
+#include "lv_obj_class_private.h"
+#include "../indev/lv_indev.h"
+#include "../indev/lv_indev_private.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "../misc/lv_anim_private.h"
+#include "../misc/lv_async.h"
+#include "../core/lv_global.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define MY_CLASS (&lv_obj_class)
+#define disp_ll_p &(LV_GLOBAL_DEFAULT()->disp_ll)
+
+#define OBJ_DUMP_STRING_LEN 128
+#define LV_OBJ_NAME_MAX_LEN 128
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_obj_delete_async_cb(void * obj);
+static void obj_delete_core(lv_obj_t * obj);
+static lv_obj_tree_walk_res_t walk_core(lv_obj_t * obj, lv_obj_tree_walk_cb_t cb, void * user_data);
+static void dump_tree_core(lv_obj_t * obj, int32_t depth);
+static lv_obj_t * lv_obj_get_first_not_deleting_child(lv_obj_t * obj);
+#if LV_USE_OBJ_NAME
+    static lv_obj_t * find_by_name_direct(const lv_obj_t * parent, const char * name, size_t len);
+#endif /*LV_USE_OBJ_NAME*/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_obj_delete(lv_obj_t * obj)
+{
+    if(obj->is_deleting)
+        return;
+
+    LV_LOG_TRACE("begin (delete %p)", (void *)obj);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_obj_invalidate(obj);
+
+    lv_obj_t * par = lv_obj_get_parent(obj);
+
+    lv_display_t * disp = NULL;
+    bool act_screen_del = false;
+    if(par == NULL) {
+        disp = lv_obj_get_display(obj);
+        if(!disp) return;   /*Shouldn't happen*/
+        if(disp->act_scr == obj) act_screen_del = true;
+    }
+
+    obj_delete_core(obj);
+
+    /*Call the ancestor's event handler to the parent to notify it about the child delete*/
+    if(par && !par->is_deleting) {
+        lv_obj_scrollbar_invalidate(par);
+        lv_obj_send_event(par, LV_EVENT_CHILD_CHANGED, NULL);
+        lv_obj_send_event(par, LV_EVENT_CHILD_DELETED, NULL);
+    }
+
+    /*Handle if the active screen was deleted*/
+    if(act_screen_del) {
+        LV_LOG_WARN("the active screen was deleted");
+        disp->act_scr = NULL;
+    }
+
+    LV_ASSERT_MEM_INTEGRITY();
+    LV_LOG_TRACE("finished (delete %p)", (void *)obj);
+}
+
+void lv_obj_clean(lv_obj_t * obj)
+{
+    LV_LOG_TRACE("begin (clean %p)", (void *)obj);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_invalidate(obj);
+
+    uint32_t cnt = lv_obj_get_child_count(obj);
+    lv_obj_t * child = lv_obj_get_first_not_deleting_child(obj);
+    while(child) {
+        obj_delete_core(child);
+        child = lv_obj_get_first_not_deleting_child(obj);
+    }
+    /*Just to remove scroll animations if any*/
+    lv_obj_scroll_to(obj, 0, 0, LV_ANIM_OFF);
+    if(obj->spec_attr) {
+        obj->spec_attr->scroll.x = 0;
+        obj->spec_attr->scroll.y = 0;
+    }
+
+    if(lv_obj_get_child_count(obj) < cnt) {
+        lv_obj_send_event(obj, LV_EVENT_CHILD_CHANGED, NULL);
+        lv_obj_send_event(obj, LV_EVENT_CHILD_DELETED, NULL);
+    }
+
+    LV_ASSERT_MEM_INTEGRITY();
+
+    LV_LOG_TRACE("finished (clean %p)", (void *)obj);
+}
+
+void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_exec_cb(&a, NULL);
+    lv_anim_set_duration(&a, 1);
+    lv_anim_set_delay(&a, delay_ms);
+    lv_anim_set_completed_cb(&a, lv_obj_delete_anim_completed_cb);
+    lv_anim_start(&a);
+}
+
+void lv_obj_delete_anim_completed_cb(lv_anim_t * a)
+{
+    lv_obj_delete(a->var);
+}
+
+void lv_obj_delete_async(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_async_call(lv_obj_delete_async_cb, obj);
+}
+
+void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_ASSERT_OBJ(parent, MY_CLASS);
+
+    if(obj->parent == NULL) {
+        LV_LOG_WARN("Can't set the parent of a screen");
+        return;
+    }
+
+    if(parent == NULL) {
+        LV_LOG_WARN("Can't set parent == NULL to an object");
+        return;
+    }
+
+    if(parent == obj->parent) {
+        return;
+    }
+
+    lv_obj_invalidate(obj);
+
+    lv_obj_allocate_spec_attr(parent);
+
+    lv_obj_t * old_parent = obj->parent;
+    /*Remove the object from the old parent's child list*/
+    int32_t i;
+    for(i = lv_obj_get_index(obj); i <= (int32_t)lv_obj_get_child_count(old_parent) - 2; i++) {
+        old_parent->spec_attr->children[i] = old_parent->spec_attr->children[i + 1];
+    }
+    old_parent->spec_attr->child_cnt--;
+    if(old_parent->spec_attr->child_cnt) {
+        old_parent->spec_attr->children = lv_realloc(old_parent->spec_attr->children,
+                                                     old_parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
+    }
+    else {
+        lv_free(old_parent->spec_attr->children);
+        old_parent->spec_attr->children = NULL;
+    }
+
+    /*Add the child to the new parent as the last (newest child)*/
+    parent->spec_attr->child_cnt++;
+    parent->spec_attr->children = lv_realloc(parent->spec_attr->children,
+                                             parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
+    parent->spec_attr->children[lv_obj_get_child_count(parent) - 1] = obj;
+
+    obj->parent = parent;
+
+    /*Notify the original parent because one of its children is lost*/
+    lv_obj_scrollbar_invalidate(old_parent);
+    lv_obj_send_event(old_parent, LV_EVENT_CHILD_CHANGED, obj);
+    lv_obj_send_event(old_parent, LV_EVENT_CHILD_DELETED, NULL);
+
+    /*Notify the new parent about the child*/
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, obj);
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CREATED, NULL);
+
+    lv_obj_mark_layout_as_dirty(obj);
+
+    lv_obj_invalidate(obj);
+}
+
+void lv_obj_move_to_index(lv_obj_t * obj, int32_t index)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    /* Check parent validity */
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(!parent) {
+        LV_LOG_WARN("parent is NULL");
+        return;
+    }
+
+    const uint32_t parent_child_count = lv_obj_get_child_count(parent);
+    /* old_index only can be 0 or greater, this point cannot be reached if the parent is not null */
+    const int32_t old_index = lv_obj_get_index(obj);
+    LV_ASSERT(0 <= old_index);
+
+    if(index < 0) {
+        index += parent_child_count;
+    }
+
+    /* Index was negative and the absolute value is greater than parent child count */
+    if((index < 0)
+       /* Index is same or bigger than parent child count */
+       || (index >= (int32_t) parent_child_count)
+       /* If both previous and new index are the same */
+       || (index == old_index)) {
+
+        return;
+    }
+
+    int32_t i = old_index;
+    if(index < old_index) {
+        while(i > index)  {
+            parent->spec_attr->children[i] = parent->spec_attr->children[i - 1];
+            i--;
+        }
+    }
+    else {
+        while(i < index) {
+            parent->spec_attr->children[i] = parent->spec_attr->children[i + 1];
+            i++;
+        }
+    }
+
+    parent->spec_attr->children[index] = obj;
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, NULL);
+    lv_obj_invalidate(parent);
+}
+
+void lv_obj_swap(lv_obj_t * obj1, lv_obj_t * obj2)
+{
+    LV_ASSERT_OBJ(obj1, MY_CLASS);
+    LV_ASSERT_OBJ(obj2, MY_CLASS);
+
+    lv_obj_t * parent = lv_obj_get_parent(obj1);
+    lv_obj_t * parent2 = lv_obj_get_parent(obj2);
+
+    uint_fast32_t index1 = lv_obj_get_index(obj1);
+    uint_fast32_t index2 = lv_obj_get_index(obj2);
+
+    lv_obj_send_event(parent2, LV_EVENT_CHILD_DELETED, obj2);
+    lv_obj_send_event(parent, LV_EVENT_CHILD_DELETED, obj1);
+
+    parent->spec_attr->children[index1] = obj2;
+    obj2->parent = parent;
+
+    parent2->spec_attr->children[index2] = obj1;
+    obj1->parent = parent2;
+
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CHANGED, obj2);
+    lv_obj_send_event(parent, LV_EVENT_CHILD_CREATED, obj2);
+    lv_obj_send_event(parent2, LV_EVENT_CHILD_CHANGED, obj1);
+    lv_obj_send_event(parent2, LV_EVENT_CHILD_CREATED, obj1);
+
+    lv_obj_invalidate(parent);
+
+    if(parent != parent2) {
+        lv_obj_invalidate(parent2);
+    }
+    lv_group_swap_obj(obj1, obj2);
+}
+
+lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    const lv_obj_t * par = obj;
+    const lv_obj_t * act_par;
+
+    do {
+        act_par = par;
+        par = lv_obj_get_parent(act_par);
+    } while(par != NULL);
+
+    return (lv_obj_t *)act_par;
+}
+
+lv_display_t * lv_obj_get_display(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    const lv_obj_t * scr;
+
+    if(obj->parent == NULL) scr = obj;  /*`obj` is a screen*/
+    else scr = lv_obj_get_screen(obj);  /*get the screen of `obj`*/
+
+    lv_display_t * d;
+    lv_ll_t * disp_head = disp_ll_p;
+    LV_LL_READ(disp_head, d) {
+        uint32_t i;
+        for(i = 0; i < d->screen_cnt; i++) {
+            if(d->screens[i] == scr) return d;
+        }
+    }
+
+    LV_LOG_WARN("No screen found");
+    return NULL;
+}
+
+lv_obj_t * lv_obj_get_parent(const lv_obj_t * obj)
+{
+    if(obj == NULL) return NULL;
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    return obj->parent;
+}
+
+lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t idx)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr == NULL) return NULL;
+
+    uint32_t idu;
+    if(idx < 0) {
+        idx = obj->spec_attr->child_cnt + idx;
+        if(idx < 0) return NULL;
+        idu = (uint32_t) idx;
+    }
+    else {
+        idu = idx;
+    }
+
+    if(idu >= obj->spec_attr->child_cnt) return NULL;
+    else return obj->spec_attr->children[idx];
+}
+
+lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr == NULL) return NULL;
+
+    int32_t i;
+    int32_t cnt = (int32_t)obj->spec_attr->child_cnt;
+    if(idx >= 0) {
+        for(i = 0; i < cnt; i++) {
+            if(obj->spec_attr->children[i]->class_p == class_p) {
+                if(idx == 0) return obj->spec_attr->children[i];
+                else idx--;
+            }
+        }
+    }
+    else {
+        idx++;   /*-1 means the first child*/
+        for(i = cnt - 1; i >= 0; i--) {
+            if(obj->spec_attr->children[i]->class_p == class_p) {
+                if(idx == 0) return obj->spec_attr->children[i];
+                else idx++;
+            }
+        }
+    }
+    return NULL;
+}
+
+lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx)
+{
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    int32_t sibling_idx = (int32_t)lv_obj_get_index(obj) + idx;
+    if(sibling_idx < 0) return NULL;
+
+    return lv_obj_get_child(parent, sibling_idx);
+}
+
+lv_obj_t * lv_obj_get_sibling_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    int32_t sibling_idx = (int32_t)lv_obj_get_index_by_type(obj, class_p) + idx;
+    if(sibling_idx < 0) return NULL;
+
+    return lv_obj_get_child_by_type(parent, sibling_idx, class_p);
+}
+
+uint32_t lv_obj_get_child_count(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(obj->spec_attr == NULL) return 0;
+    return obj->spec_attr->child_cnt;
+}
+
+uint32_t lv_obj_get_child_count_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(obj->spec_attr == NULL) return 0;
+
+    uint32_t i;
+    uint32_t cnt = 0;
+    for(i = 0; i < obj->spec_attr->child_cnt; i++) {
+        if(obj->spec_attr->children[i]->class_p == class_p) cnt++;
+    }
+    return cnt;
+}
+
+#if LV_USE_OBJ_NAME
+
+void lv_obj_set_name(lv_obj_t * obj, const char * name)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_allocate_spec_attr(obj);
+
+    if(!obj->spec_attr->name_static && obj->spec_attr->name) lv_free((void *)obj->spec_attr->name);
+
+    if(name == NULL) {
+        obj->spec_attr->name = NULL;
+        obj->spec_attr->name_static = 1;
+    }
+    else {
+        obj->spec_attr->name = lv_strdup(name);
+        obj->spec_attr->name_static = 0;
+    }
+}
+
+void lv_obj_set_name_static(lv_obj_t * obj, const char * name)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_allocate_spec_attr(obj);
+
+    if(!obj->spec_attr->name_static && obj->spec_attr->name) lv_free((void *)obj->spec_attr->name);
+
+    obj->spec_attr->name = name;
+    obj->spec_attr->name_static = 1;
+}
+
+const char * lv_obj_get_name(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr == NULL) return NULL;
+    else return obj->spec_attr->name;
+}
+
+void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    const char * name = lv_obj_get_name(obj);
+    /*Use a default name which auto-indexing*/
+    char name_buf[LV_OBJ_NAME_MAX_LEN];
+    if(name == NULL) {
+        lv_snprintf(name_buf, sizeof(name_buf), "%s_#", obj->class_p->name);
+        name = name_buf;
+    }
+
+    size_t name_len = lv_strlen(name);
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+
+    /*If the last character is # automatically index the children with the same name start*/
+    if(parent && name_len > 0 && name[name_len - 1] == '#') {
+        uint32_t child_cnt = lv_obj_get_child_count(parent);
+        uint32_t cnt = 0;
+        uint32_t i;
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = lv_obj_get_child(parent, i);
+            /*All siblings older siblings are checked, craft the name of this widget*/
+            if(child == obj) {
+                char num_buf[8];
+                size_t num_len;
+                num_len = lv_snprintf(num_buf, sizeof(num_buf), "%d", cnt);
+                /*Is there enough space for the name and the index?*/
+                if(buf_size > name_len + num_len) {
+                    /*E.g. buf = "some_name_", so trim the # from the end*/
+                    lv_strncpy(buf, name, name_len - 1);
+                    lv_strcpy(&buf[name_len - 1], num_buf);
+                }
+                else {
+                    /*Use the name as it is as a fallback*/
+                    lv_strlcpy(buf, obj->spec_attr->name, buf_size);
+                }
+                break;
+            }
+            /*Check the older siblings. IF they start with the same name count them*/
+            else {
+                const char * child_name = lv_obj_get_name(child);
+                if(child_name == NULL) {
+                    /*If the name we are looking for start with the child's class name
+                     *increment the index. E.g. <class_name>_#*/
+                    size_t class_name_len = lv_strlen(child->class_p->name);
+                    if(name_len > 3 && class_name_len == name_len - 2 &&
+                       lv_strncmp(child->class_p->name, name, class_name_len) == 0) {
+                        cnt++;
+                    }
+                }
+                /*The name is set, check if it's e.g. <some_name>#*/
+                else {
+                    if(lv_strcmp(child->spec_attr->name, name) == 0) {
+                        cnt++;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        /*Just use the set name*/
+        lv_strlcpy(buf, obj->spec_attr->name, buf_size);
+    }
+}
+
+lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * path)
+{
+    LV_ASSERT_OBJ(parent, MY_CLASS);
+
+    if(parent == NULL || parent->spec_attr == NULL || path == NULL) return NULL;
+
+    while(*path) {
+        const char * segment = path;
+        uint32_t len = 0;
+
+        /* Calculate the length of the current segment */
+        while(path[len] && path[len] != '/')
+            len++;
+
+        /* Look for a child whose resolved name exactly matches the segment */
+        lv_obj_t * child = find_by_name_direct(parent, segment, len);
+        if(!child) return NULL; /*Segment not found*/
+
+        /* Advance to the next segment */
+        path += len;
+        if(*path == '/') path++; /* Skip the '/' */
+
+        /* If there is no further segment, we've found the target child */
+        if(*path == '\0') return child;
+
+        parent = child;
+    }
+
+    return NULL;
+
+}
+
+lv_obj_t * lv_obj_find_by_name(const lv_obj_t * parent, const char * name)
+{
+    if(parent == NULL) parent = lv_display_get_screen_active(NULL);
+    if(parent == NULL) return NULL;
+
+    lv_obj_t * child = find_by_name_direct(parent, name, UINT16_MAX);
+    if(child) return child;
+
+    /*Search children recursively*/
+    uint32_t child_cnt = lv_obj_get_child_count(parent);
+    uint32_t i;
+    for(i = 0; i < child_cnt; i++) {
+        child = parent->spec_attr->children[i];
+        lv_obj_t * found = lv_obj_find_by_name(child, name);
+        if(found != NULL) return found;
+    }
+
+    return NULL;
+}
+
+#endif /*LV_USE_OBJ_NAME*/
+
+int32_t lv_obj_get_index(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent == NULL) return -1;
+
+    int32_t i = 0;
+    for(i = 0; i < parent->spec_attr->child_cnt; i++) {
+        if(parent->spec_attr->children[i] == obj) return i;
+    }
+
+    /*Shouldn't reach this point*/
+    LV_ASSERT(0);
+    return -1;
+}
+
+int32_t lv_obj_get_index_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent == NULL) return 0xFFFFFFFF;
+
+    uint32_t i = 0;
+    uint32_t idx = 0;
+    for(i = 0; i < parent->spec_attr->child_cnt; i++) {
+        lv_obj_t * child = parent->spec_attr->children[i];
+        if(child->class_p == class_p) {
+            if(child == obj) return idx;
+            idx++;
+        }
+    }
+
+    /*Can happen if there was no children with the given type*/
+    return -1;
+}
+
+void lv_obj_tree_walk(lv_obj_t * start_obj, lv_obj_tree_walk_cb_t cb, void * user_data)
+{
+    walk_core(start_obj, cb, user_data);
+}
+
+void lv_obj_dump_tree(lv_obj_t * start_obj)
+{
+    if(start_obj == NULL) {
+        lv_display_t * disp = lv_display_get_next(NULL);
+        while(disp) {
+            uint32_t i;
+            for(i = 0; i < disp->screen_cnt; i++) {
+                dump_tree_core(disp->screens[i], 0);
+            }
+            disp = lv_display_get_next(disp);
+        }
+    }
+    else {
+        dump_tree_core(start_obj, 0);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_obj_delete_async_cb(void * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_obj_delete(obj);
+}
+
+static void obj_indev_reset(lv_indev_t * indev, lv_obj_t * obj)
+{
+    /* If the input device is already in the release state,
+     * there is no need to wait for the input device to be released
+     */
+    if(lv_indev_get_state(indev) != LV_INDEV_STATE_RELEASED) {
+        /*Wait for release to avoid accidentally triggering other obj to be clicked*/
+        lv_indev_wait_release(indev);
+    }
+
+    /*Reset the input device*/
+    lv_indev_reset(indev, obj);
+}
+
+static void obj_delete_core(lv_obj_t * obj)
+{
+    if(obj->is_deleting)
+        return;
+
+    obj->is_deleting = true;
+
+    /*Let the user free the resources used in `LV_EVENT_DELETE`*/
+    lv_result_t res = lv_obj_send_event(obj, LV_EVENT_DELETE, NULL);
+    if(res == LV_RESULT_INVALID) {
+        obj->is_deleting = false;
+        return;
+    }
+
+    /*Clean registered event_cb*/
+    if(obj->spec_attr) lv_event_remove_all(&(obj->spec_attr->event_list));
+
+    /*Recursively delete the children*/
+    lv_obj_t * child = lv_obj_get_child(obj, 0);
+    while(child) {
+        obj_delete_core(child);
+        child = lv_obj_get_child(obj, 0);
+    }
+
+    lv_group_t * group = lv_obj_get_group(obj);
+
+    /*Reset all input devices if the object to delete is used*/
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    while(indev) {
+        lv_indev_type_t indev_type = lv_indev_get_type(indev);
+        if(indev_type == LV_INDEV_TYPE_POINTER || indev_type == LV_INDEV_TYPE_BUTTON) {
+            if(indev->pointer.act_obj == obj || indev->pointer.last_obj == obj || indev->pointer.scroll_obj == obj) {
+                obj_indev_reset(indev, obj);
+            }
+            if(indev->pointer.last_pressed == obj) {
+                indev->pointer.last_pressed = NULL;
+            }
+            if(indev->pointer.last_hovered == obj) {
+                indev->pointer.last_hovered = NULL;
+            }
+        }
+
+        if(indev->group == group && obj == lv_indev_get_active_obj()) {
+            obj_indev_reset(indev, obj);
+        }
+        indev = lv_indev_get_next(indev);
+    }
+
+    /*Delete all pending async del-s*/
+    lv_result_t async_cancel_res = LV_RESULT_OK;
+    while(async_cancel_res == LV_RESULT_OK) {
+        async_cancel_res = lv_async_call_cancel(lv_obj_delete_async_cb, obj);
+    }
+
+    /*All children deleted. Now clean up the object specific data*/
+    lv_obj_destruct(obj);
+
+    /*Remove the screen for the screen list*/
+    if(obj->parent == NULL) {
+        lv_display_t * disp = lv_obj_get_display(obj);
+        uint32_t i;
+        /*Find the screen in the list*/
+        for(i = 0; i < disp->screen_cnt; i++) {
+            if(disp->screens[i] == obj) break;
+        }
+
+        uint32_t id = i;
+        for(i = id; i < disp->screen_cnt - 1; i++) {
+            disp->screens[i] = disp->screens[i + 1];
+        }
+        disp->screen_cnt--;
+        disp->screens = lv_realloc(disp->screens, disp->screen_cnt * sizeof(lv_obj_t *));
+    }
+    /*Remove the object from the child list of its parent*/
+    else {
+        int32_t id = lv_obj_get_index(obj);
+        uint16_t i;
+        for(i = id; i < obj->parent->spec_attr->child_cnt - 1; i++) {
+            obj->parent->spec_attr->children[i] = obj->parent->spec_attr->children[i + 1];
+        }
+        obj->parent->spec_attr->child_cnt--;
+        obj->parent->spec_attr->children = lv_realloc(obj->parent->spec_attr->children,
+                                                      obj->parent->spec_attr->child_cnt * sizeof(lv_obj_t *));
+    }
+
+    /*Free the object itself*/
+    lv_free(obj);
+}
+
+static lv_obj_tree_walk_res_t walk_core(lv_obj_t * obj, lv_obj_tree_walk_cb_t cb, void * user_data)
+{
+    lv_obj_tree_walk_res_t res = LV_OBJ_TREE_WALK_NEXT;
+
+    if(obj == NULL) {
+        lv_display_t * disp = lv_display_get_next(NULL);
+        while(disp) {
+            uint32_t i;
+            for(i = 0; i < disp->screen_cnt; i++) {
+                walk_core(disp->screens[i], cb, user_data);
+            }
+            disp = lv_display_get_next(disp);
+        }
+        return LV_OBJ_TREE_WALK_END;    /*The value doesn't matter as it wasn't called recursively*/
+    }
+
+    res = cb(obj, user_data);
+
+    if(res == LV_OBJ_TREE_WALK_END) return LV_OBJ_TREE_WALK_END;
+
+    if(res != LV_OBJ_TREE_WALK_SKIP_CHILDREN) {
+        uint32_t i;
+        for(i = 0; i < lv_obj_get_child_count(obj); i++) {
+            res = walk_core(lv_obj_get_child(obj, i), cb, user_data);
+            if(res == LV_OBJ_TREE_WALK_END) return LV_OBJ_TREE_WALK_END;
+        }
+    }
+    return LV_OBJ_TREE_WALK_NEXT;
+}
+
+static void dump_tree_core(lv_obj_t * obj, int32_t depth)
+{
+#if LV_USE_LOG
+    const char * id;
+
+#if LV_USE_OBJ_ID
+    char buf[OBJ_DUMP_STRING_LEN];
+    id = lv_obj_stringify_id(obj, buf, sizeof(buf));
+    if(id == NULL) id = "obj0";
+#else
+    id = "obj0";
+#endif
+
+    /*id of `obj0` is an invalid id for builtin id*/
+    LV_LOG_USER("%*sobj:%p, id:%s;", (int)(2 * depth), "", (void *)obj, id);
+#endif /*LV_USE_LOG*/
+
+    if(obj && obj->spec_attr && obj->spec_attr->child_cnt) {
+        for(uint32_t i = 0; i < obj->spec_attr->child_cnt; i++) {
+            dump_tree_core(lv_obj_get_child(obj, i), depth + 1);
+        }
+    }
+}
+
+static lv_obj_t * lv_obj_get_first_not_deleting_child(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj->spec_attr == NULL) return NULL;
+
+    int32_t i;
+    int32_t cnt = (int32_t)obj->spec_attr->child_cnt;
+    for(i = 0; i < cnt; i++) {
+        if(!obj->spec_attr->children[i]->is_deleting) {
+            return obj->spec_attr->children[i];
+        }
+    }
+
+    return NULL;
+}
+
+#if LV_USE_OBJ_NAME
+
+static lv_obj_t * find_by_name_direct(const lv_obj_t * parent, const char * name, size_t len)
+{
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_count(parent);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = parent->spec_attr->children[i];
+
+        char child_name_resolved[LV_OBJ_NAME_MAX_LEN];
+        lv_obj_get_name_resolved(child, child_name_resolved, sizeof(child_name_resolved));
+        if(lv_strncmp(child_name_resolved, name, len) == 0) return child;
+    }
+
+    return NULL;
+}
+
+#endif /*LV_USE_OBJ_NAME*/

components/easylvgl/lvgl9/src/core/lv_obj_tree.h

@@ -0,0 +1,321 @@
+/**
+ * @file lv_obj_tree.h
+ *
+ */
+
+#ifndef LV_OBJ_TREE_H
+#define LV_OBJ_TREE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_anim.h"
+#include "../display/lv_display.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_OBJ_TREE_WALK_NEXT,
+    LV_OBJ_TREE_WALK_SKIP_CHILDREN,
+    LV_OBJ_TREE_WALK_END,
+} lv_obj_tree_walk_res_t;
+
+typedef lv_obj_tree_walk_res_t (*lv_obj_tree_walk_cb_t)(lv_obj_t *, void *);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Delete an object and all of its children.
+ * Also remove the objects from their group and remove all animations (if any).
+ * Send `LV_EVENT_DELETE` to deleted objects.
+ * @param obj       pointer to an object
+ */
+void lv_obj_delete(lv_obj_t * obj);
+
+/**
+ * Delete all children of an object.
+ * Also remove the objects from their group and remove all animations (if any).
+ * Send `LV_EVENT_DELETE` to deleted objects.
+ * @param obj       pointer to an object
+ */
+void lv_obj_clean(lv_obj_t * obj);
+
+/**
+ * Delete an object after some delay
+ * @param obj       pointer to an object
+ * @param delay_ms  time to wait before delete in milliseconds
+ */
+void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms);
+
+/**
+ * A function to be easily used in animation ready callback to delete an object when the animation is ready
+ * @param a         pointer to the animation
+ */
+void lv_obj_delete_anim_completed_cb(lv_anim_t * a);
+
+/**
+ * Helper function for asynchronously deleting objects.
+ * Useful for cases where you can't delete an object directly in an `LV_EVENT_DELETE` handler (i.e. parent).
+ * @param obj       object to delete
+ * @see lv_async_call
+ */
+void lv_obj_delete_async(lv_obj_t * obj);
+
+/**
+ * Move the parent of an object. The relative coordinates will be kept.
+ *
+ * @param obj       pointer to an object whose parent needs to be changed
+ * @param parent pointer to the new parent
+ */
+void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent);
+
+/**
+ * Swap the positions of two objects.
+ * When used in listboxes, it can be used to sort the listbox items.
+ * @param obj1  pointer to the first object
+ * @param obj2  pointer to the second object
+ */
+void lv_obj_swap(lv_obj_t * obj1, lv_obj_t * obj2);
+
+/**
+ * moves the object to the given index in its parent.
+ * When used in listboxes, it can be used to sort the listbox items.
+ * @param obj  pointer to the object to be moved.
+ * @param index  new index in parent. -1 to count from the back
+ * @note to move to the background: lv_obj_move_to_index(obj, 0)
+ * @note to move forward (up): lv_obj_move_to_index(obj, lv_obj_get_index(obj) - 1)
+ */
+void lv_obj_move_to_index(lv_obj_t * obj, int32_t index);
+
+/**
+ * Get the screen of an object
+ * @param obj       pointer to an object
+ * @return          pointer to the object's screen
+ */
+lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj);
+
+/**
+ * Get the display of the object
+ * @param obj       pointer to an object
+ * @return          pointer to the object's display
+ */
+lv_display_t * lv_obj_get_display(const lv_obj_t * obj);
+
+/**
+ * Get the parent of an object
+ * @param obj       pointer to an object
+ * @return          the parent of the object. (NULL if `obj` was a screen)
+ */
+lv_obj_t * lv_obj_get_parent(const lv_obj_t * obj);
+
+/**
+ * Get the child of an object by the child's index.
+ * @param obj       pointer to an object whose child should be get
+ * @param idx       the index of the child.
+ *                  0: the oldest (firstly created) child
+ *                  1: the second oldest
+ *                  child count-1: the youngest
+ *                  -1: the youngest
+ *                  -2: the second youngest
+ * @return          pointer to the child or NULL if the index was invalid
+ */
+lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t idx);
+
+/**
+ * Get the child of an object by the child's index. Consider the children only with a given type.
+ * @param obj       pointer to an object whose child should be get
+ * @param idx       the index of the child.
+ *                  0: the oldest (firstly created) child
+ *                  1: the second oldest
+ *                  child count-1: the youngest
+ *                  -1: the youngest
+ *                  -2: the second youngest
+ * @param class_p   the type of the children to check
+ * @return          pointer to the child or NULL if the index was invalid
+ */
+lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx,
+                                    const lv_obj_class_t * class_p);
+
+/**
+ * Return a sibling of an object
+ * @param obj       pointer to an object whose sibling should be get
+ * @param idx       0: `obj` itself
+ *                  -1: the first older sibling
+ *                  -2: the next older sibling
+ *                  1: the first younger sibling
+ *                  2: the next younger sibling
+ *                  etc
+ * @return          pointer to the requested sibling  or NULL if there is no such sibling
+ */
+lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx);
+
+/**
+ * Return a sibling of an object. Consider the siblings only with a given type.
+ * @param obj       pointer to an object whose sibling should be get
+ * @param idx       0: `obj` itself
+ *                  -1: the first older sibling
+ *                  -2: the next older sibling
+ *                  1: the first younger sibling
+ *                  2: the next younger sibling
+ *                  etc
+ * @param class_p   the type of the children to check
+ * @return          pointer to the requested sibling  or NULL if there is no such sibling
+ */
+lv_obj_t * lv_obj_get_sibling_by_type(const lv_obj_t * obj, int32_t idx,
+                                      const lv_obj_class_t * class_p);
+
+/**
+ * Get the number of children
+ * @param obj       pointer to an object
+ * @return          the number of children
+ */
+uint32_t lv_obj_get_child_count(const lv_obj_t * obj);
+
+/**
+ * Get the number of children having a given type.
+ * @param obj       pointer to an object
+ * @param class_p   the type of the children to check
+ * @return          the number of children
+ */
+
+uint32_t lv_obj_get_child_count_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p);
+
+#if LV_USE_OBJ_NAME
+
+/**
+ * Set a name for a widget. The name will be allocated and freed when the
+ * widget is deleted or a new name is set.
+ * @param obj       pointer to an object
+ * @param name      the name to set. If set to `NULL` the default "<widget_type>_#"
+ *                  name will be used.
+ * @note If the name ends with a `#`, older siblings with the same name
+ * will be counted, and the `#` will be replaced by the index of the
+ * given widget. For example, creating multiple widgets with the name
+ * "mybtn_#" will result in resolved names like "mybtn_0", "mybtn_1",
+ * "mybtn_2", etc.  The name is resolved when `lv_obj_get_name_resolved`
+ * is called, so the result reflects the currently existing widgets at
+ * that time.
+ */
+void lv_obj_set_name(lv_obj_t * obj, const char * name);
+
+/**
+ * Set a name for a widget. Only a pointer will be saved.
+ * @param obj       pointer to an object
+ * @param name      the name to set. If set to `NULL` the default "<widget_type>_#"
+ *                  name will be used.
+ * @note If the name ends with a `#`, older siblings with the same name
+ * will be counted, and the `#` will be replaced by the index of the
+ * given widget. For example, creating multiple widgets with the name
+ * "mybtn_#" will result in resolved names like "mybtn_0", "mybtn_1",
+ * "mybtn_2", etc.  The name is resolved when `lv_obj_get_name_resolved`
+ * is called, so the result reflects the currently existing widgets at
+ * that time.
+ */
+void lv_obj_set_name_static(lv_obj_t * obj, const char * name);
+
+/**
+ * Get the set name as it was set.
+ * @param obj       pointer to an object
+ * @return          get the set name or NULL if it wasn't set yet
+ */
+const char * lv_obj_get_name(const lv_obj_t * obj);
+
+/**
+ * Get the set name or craft a name automatically.
+ * @param obj       pointer to an object
+ * @param buf       buffer to store the name
+ * @param buf_size  the size of the buffer in bytes
+ * @note If the name ends with a `#`, older siblings with the same name
+ * will be counted, and the `#` will be replaced by the index of the
+ * given widget. For example, creating multiple widgets with the name
+ * "mybtn_#" will result in resolved names like "mybtn_0", "mybtn_1",
+ * "mybtn_2", etc.  The name is resolved when `lv_obj_get_name_resolved`
+ * is called, so the result reflects the currently existing widgets at
+ * that time.
+ */
+void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size);
+
+/**
+ * Find a child with a given name on a parent. This child doesn't have to be the
+ * direct child of the parent. First direct children of the parent will be checked,
+ * and the direct children of the first child, etc. (Breadth-first search).
+ *
+ * If the name of a widget was not set a name like "lv_button_1" will
+ * be created for it using `lv_obj_get_name_resolved`.
+ *
+ * @param parent        the widget where the search should start
+ * @return              the found widget or NULL if not found.
+ */
+lv_obj_t * lv_obj_find_by_name(const lv_obj_t * parent, const char * name);
+
+/**
+ * Get an object by name. The name can be a path too, for example
+ * "main_container/lv_button_1/label".
+ * In this case the first part of the name-path should be the direct child of the parent,
+ * the second part, should the direct child of first one, etc.
+ *
+ * If the name of a widget was not set a name like "lv_button_1" will
+ * be created for it using `lv_obj_get_name_resolved`.
+ *
+ * @param parent        the widget where the search should start
+ * @return              the found widget or NULL if not found.
+ */
+lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * name_path);
+
+#endif /*LV_USE_OBJ_NAME*/
+
+/**
+ * Get the index of a child.
+ * @param obj       pointer to an object
+ * @return          the child index of the object.
+ *                  E.g. 0: the oldest (firstly created child).
+ *                  (-1 if child could not be found or no parent exists)
+ */
+int32_t lv_obj_get_index(const lv_obj_t * obj);
+
+/**
+ * Get the index of a child. Consider the children only with a given type.
+ * @param obj       pointer to an object
+ * @param class_p   the type of the children to check
+ * @return          the child index of the object.
+ *                  E.g. 0: the oldest (firstly created child with the given class).
+ *                  (-1 if child could not be found or no parent exists)
+ */
+int32_t lv_obj_get_index_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p);
+
+/**
+ * Iterate through all children of any object.
+ * @param start_obj     start integrating from this object
+ * @param cb            call this callback on the objects
+ * @param user_data     pointer to any user related data (will be passed to `cb`)
+ */
+void lv_obj_tree_walk(lv_obj_t * start_obj, lv_obj_tree_walk_cb_t cb, void * user_data);
+
+/**
+ * Iterate through all children of any object and print their ID.
+ * @param start_obj     start integrating from this object
+ */
+void lv_obj_dump_tree(lv_obj_t * start_obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_TREE_H*/

components/easylvgl/lvgl9/src/core/lv_refr.c

@@ -0,0 +1,1450 @@
+/**
+ * @file lv_refr.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_refr_private.h"
+#include "lv_obj_draw_private.h"
+#include "../misc/lv_area_private.h"
+#include "../draw/sw/lv_draw_sw_mask_private.h"
+#include "../draw/lv_draw_mask_private.h"
+#include "lv_obj_private.h"
+#include "lv_obj_event_private.h"
+#include "../display/lv_display.h"
+#include "../display/lv_display_private.h"
+#include "../tick/lv_tick.h"
+#include "../misc/lv_timer_private.h"
+#include "../misc/lv_math.h"
+#include "../misc/lv_profiler.h"
+#include "../misc/lv_types.h"
+#include "../draw/lv_draw_private.h"
+#include "../font/lv_font_fmt_txt.h"
+#include "../stdlib/lv_string.h"
+#include "lv_global.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/*Display being refreshed*/
+#define disp_refr LV_GLOBAL_DEFAULT()->disp_refresh
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_refr_join_area(void);
+static void refr_invalid_areas(void);
+static void refr_sync_areas(void);
+static void refr_area(const lv_area_t * area_p, int32_t y_offset);
+static void refr_configured_layer(lv_layer_t * layer);
+static void refr_obj_and_children(lv_layer_t * layer, lv_obj_t * top_obj);
+static uint32_t get_max_row(lv_display_t * disp, int32_t area_w, int32_t area_h);
+static void draw_buf_flush(lv_display_t * disp);
+static void call_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map);
+static void wait_for_flushing(lv_display_t * disp);
+static lv_result_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type_t layer_type,
+                                  lv_area_t * layer_area_out, lv_area_t * obj_draw_size_out);
+static bool alpha_test_area_on_obj(lv_obj_t * obj, const lv_area_t * area);
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    static bool refr_check_obj_clip_overflow(lv_layer_t * layer, lv_obj_t * obj);
+    static void refr_obj_matrix(lv_layer_t * layer, lv_obj_t * obj);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#if LV_USE_LOG && LV_LOG_TRACE_DISP_REFR
+    #define LV_TRACE_REFR(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+    #define LV_TRACE_REFR(...)
+#endif
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the screen refresh subsystem
+ */
+void lv_refr_init(void)
+{
+}
+
+void lv_refr_deinit(void)
+{
+}
+
+void lv_refr_now(lv_display_t * disp)
+{
+    lv_anim_refr_now();
+
+    if(disp) {
+        if(disp->refr_timer) lv_display_refr_timer(disp->refr_timer);
+    }
+    else {
+        lv_display_t * d;
+        d = lv_display_get_next(NULL);
+        while(d) {
+            if(d->refr_timer) lv_display_refr_timer(d->refr_timer);
+            d = lv_display_get_next(d);
+        }
+    }
+}
+
+void lv_obj_redraw(lv_layer_t * layer, lv_obj_t * obj)
+{
+    LV_PROFILER_REFR_BEGIN;
+    lv_area_t clip_area_ori = layer->_clip_area;
+    lv_area_t clip_coords_for_obj;
+
+    /*Truncate the clip area to `obj size + ext size` area*/
+    lv_area_t obj_coords_ext;
+    lv_obj_get_coords(obj, &obj_coords_ext);
+    int32_t ext_draw_size = lv_obj_get_ext_draw_size(obj);
+    lv_area_increase(&obj_coords_ext, ext_draw_size, ext_draw_size);
+
+    if(!lv_area_intersect(&clip_coords_for_obj, &clip_area_ori, &obj_coords_ext)) {
+        LV_PROFILER_REFR_END;
+        return;
+    }
+    /*If the object is visible on the current clip area*/
+    layer->_clip_area = clip_coords_for_obj;
+
+    lv_obj_send_event(obj, LV_EVENT_DRAW_MAIN_BEGIN, layer);
+    lv_obj_send_event(obj, LV_EVENT_DRAW_MAIN, layer);
+    lv_obj_send_event(obj, LV_EVENT_DRAW_MAIN_END, layer);
+#if LV_USE_REFR_DEBUG
+    lv_color_t debug_color = lv_color_make(lv_rand(0, 0xFF), lv_rand(0, 0xFF), lv_rand(0, 0xFF));
+    lv_draw_rect_dsc_t draw_dsc;
+    lv_draw_rect_dsc_init(&draw_dsc);
+    draw_dsc.bg_color = debug_color;
+    draw_dsc.bg_opa = LV_OPA_20;
+    draw_dsc.border_width = 1;
+    draw_dsc.border_opa = LV_OPA_30;
+    draw_dsc.border_color = debug_color;
+    lv_draw_rect(layer, &draw_dsc, &obj_coords_ext);
+#endif
+
+    const lv_area_t * obj_coords;
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_OVERFLOW_VISIBLE)) {
+        obj_coords = &obj_coords_ext;
+    }
+    else {
+        obj_coords = &obj->coords;
+    }
+    lv_area_t clip_coords_for_children;
+    bool refr_children = true;
+    if(!lv_area_intersect(&clip_coords_for_children, &layer->_clip_area, obj_coords) || layer->opa <= LV_OPA_MIN) {
+        refr_children = false;
+    }
+
+    if(refr_children) {
+        uint32_t i;
+        uint32_t child_cnt = lv_obj_get_child_count(obj);
+        if(child_cnt == 0) {
+            /*If the object was visible on the clip area call the post draw events too*/
+            /*If all the children are redrawn make 'post draw' draw*/
+            lv_obj_send_event(obj, LV_EVENT_DRAW_POST_BEGIN, layer);
+            lv_obj_send_event(obj, LV_EVENT_DRAW_POST, layer);
+            lv_obj_send_event(obj, LV_EVENT_DRAW_POST_END, layer);
+        }
+        else {
+            layer->_clip_area = clip_coords_for_children;
+            bool clip_corner = lv_obj_get_style_clip_corner(obj, LV_PART_MAIN);
+
+            int32_t radius = 0;
+            if(clip_corner) {
+                radius = lv_obj_get_style_radius(obj, LV_PART_MAIN);
+                if(radius == 0) clip_corner = false;
+            }
+
+            if(clip_corner == false) {
+                for(i = 0; i < child_cnt; i++) {
+                    lv_obj_t * child = obj->spec_attr->children[i];
+                    lv_obj_refr(layer, child);
+                }
+
+                /*If the object was visible on the clip area call the post draw events too*/
+                /*If all the children are redrawn make 'post draw' draw*/
+                lv_obj_send_event(obj, LV_EVENT_DRAW_POST_BEGIN, layer);
+                lv_obj_send_event(obj, LV_EVENT_DRAW_POST, layer);
+                lv_obj_send_event(obj, LV_EVENT_DRAW_POST_END, layer);
+            }
+            else {
+                lv_layer_t * layer_children;
+                lv_draw_mask_rect_dsc_t mask_draw_dsc;
+                lv_draw_mask_rect_dsc_init(&mask_draw_dsc);
+                mask_draw_dsc.radius = radius;
+                mask_draw_dsc.area = obj->coords;
+
+                lv_draw_image_dsc_t img_draw_dsc;
+                lv_draw_image_dsc_init(&img_draw_dsc);
+
+                int32_t short_side = LV_MIN(lv_area_get_width(&obj->coords), lv_area_get_height(&obj->coords));
+                int32_t rout = LV_MIN(radius, short_side >> 1);
+
+                lv_area_t bottom = obj->coords;
+                bottom.y1 = bottom.y2 - rout + 1;
+                if(lv_area_intersect(&bottom, &bottom, &layer->_clip_area)) {
+                    layer_children = lv_draw_layer_create(layer, LV_COLOR_FORMAT_ARGB8888, &bottom);
+
+                    for(i = 0; i < child_cnt; i++) {
+                        lv_obj_t * child = obj->spec_attr->children[i];
+                        lv_obj_refr(layer_children, child);
+                    }
+
+                    /*If all the children are redrawn send 'post draw' draw*/
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_BEGIN, layer_children);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST, layer_children);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_END, layer_children);
+
+                    lv_draw_mask_rect(layer_children, &mask_draw_dsc);
+
+                    img_draw_dsc.src = layer_children;
+                    lv_draw_layer(layer, &img_draw_dsc, &bottom);
+                }
+
+                lv_area_t top = obj->coords;
+                top.y2 = top.y1 + rout - 1;
+                if(lv_area_intersect(&top, &top, &layer->_clip_area)) {
+                    layer_children = lv_draw_layer_create(layer, LV_COLOR_FORMAT_ARGB8888, &top);
+
+                    for(i = 0; i < child_cnt; i++) {
+                        lv_obj_t * child = obj->spec_attr->children[i];
+                        lv_obj_refr(layer_children, child);
+                    }
+
+                    /*If all the children are redrawn send 'post draw' draw*/
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_BEGIN, layer_children);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST, layer_children);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_END, layer_children);
+
+                    lv_draw_mask_rect(layer_children, &mask_draw_dsc);
+
+                    img_draw_dsc.src = layer_children;
+                    lv_draw_layer(layer, &img_draw_dsc, &top);
+
+                }
+
+                lv_area_t mid = obj->coords;
+                mid.y1 += rout;
+                mid.y2 -= rout;
+                if(lv_area_intersect(&mid, &mid, &layer->_clip_area)) {
+                    layer->_clip_area = mid;
+                    for(i = 0; i < child_cnt; i++) {
+                        lv_obj_t * child = obj->spec_attr->children[i];
+                        lv_obj_refr(layer, child);
+                    }
+
+                    /*If all the children are redrawn make 'post draw' draw*/
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_BEGIN, layer);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST, layer);
+                    lv_obj_send_event(obj, LV_EVENT_DRAW_POST_END, layer);
+
+                }
+
+            }
+        }
+    }
+
+    layer->_clip_area = clip_area_ori;
+    LV_PROFILER_REFR_END;
+}
+
+void lv_inv_area(lv_display_t * disp, const lv_area_t * area_p)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return;
+    if(!lv_display_is_invalidation_enabled(disp)) return;
+
+    /**
+     * There are two reasons for this issue:
+     *  1.LVGL API is being used across threads, such as modifying widget properties in another thread
+     *    or within an interrupt handler during the main thread rendering process.
+     *  2.User-customized widget modify widget properties/styles again within the DRAW event.
+     *
+     * Therefore, ensure that LVGL is used in a single-threaded manner, or refer to
+     * documentation: https://docs.lvgl.io/master/porting/os.html for proper locking mechanisms.
+     * Additionally, ensure that only drawing-related tasks are performed within the DRAW event,
+     * and move widget property/style modifications to other events.
+     */
+    LV_ASSERT_MSG(!disp->rendering_in_progress, "Invalidate area is not allowed during rendering.");
+
+    /*Clear the invalidate buffer if the parameter is NULL*/
+    if(area_p == NULL) {
+        disp->inv_p = 0;
+        return;
+    }
+
+    lv_area_t scr_area;
+    scr_area.x1 = 0;
+    scr_area.y1 = 0;
+    scr_area.x2 = lv_display_get_horizontal_resolution(disp) - 1;
+    scr_area.y2 = lv_display_get_vertical_resolution(disp) - 1;
+
+    lv_area_t com_area;
+    bool suc;
+
+    suc = lv_area_intersect(&com_area, area_p, &scr_area);
+    if(suc == false)  return; /*Out of the screen*/
+
+    if(disp->color_format == LV_COLOR_FORMAT_I1) {
+        /*Make sure that the X coordinates start and end on byte boundary.
+         *E.g. convert 11;27 to 8;31*/
+        com_area.x1 &= ~0x7; /*Round down: Nx8*/
+        com_area.x2 |= 0x7;    /*Round up: Nx8 - 1*/
+    }
+
+    /*If there were at least 1 invalid area in full refresh mode, redraw the whole screen*/
+    if(disp->render_mode == LV_DISPLAY_RENDER_MODE_FULL) {
+        disp->inv_areas[0] = scr_area;
+        disp->inv_p = 1;
+        lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
+        return;
+    }
+
+    lv_result_t res = lv_display_send_event(disp, LV_EVENT_INVALIDATE_AREA, &com_area);
+    if(res != LV_RESULT_OK) return;
+
+    /*Save only if this area is not in one of the saved areas*/
+    uint16_t i;
+    for(i = 0; i < disp->inv_p; i++) {
+        if(lv_area_is_in(&com_area, &disp->inv_areas[i], 0) != false) return;
+    }
+
+    /*Save the area*/
+    lv_area_t * tmp_area_p = &com_area;
+    if(disp->inv_p >= LV_INV_BUF_SIZE) { /*If no place for the area add the screen*/
+        disp->inv_p = 0;
+        tmp_area_p = &scr_area;
+    }
+    lv_area_copy(&disp->inv_areas[disp->inv_p], tmp_area_p);
+    disp->inv_p++;
+
+    lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
+}
+
+/**
+ * Get the display which is being refreshed
+ * @return the display being refreshed
+ */
+lv_display_t * lv_refr_get_disp_refreshing(void)
+{
+    return disp_refr;
+}
+
+/**
+ * Get the display which is being refreshed
+ * @return the display being refreshed
+ */
+void lv_refr_set_disp_refreshing(lv_display_t * disp)
+{
+    disp_refr = disp;
+}
+
+void lv_display_refr_timer(lv_timer_t * tmr)
+{
+    LV_PROFILER_REFR_BEGIN;
+    LV_TRACE_REFR("begin");
+
+    if(tmr) {
+        disp_refr = tmr->user_data;
+        /* Ensure the timer does not run again automatically.
+         * This is done before refreshing in case refreshing invalidates something else.
+         * However if the performance monitor is enabled keep the timer running to count the FPS.*/
+#if !LV_USE_PERF_MONITOR
+        lv_timer_pause(tmr);
+#endif
+    }
+    else {
+        disp_refr = lv_display_get_default();
+    }
+
+    if(disp_refr == NULL) {
+        LV_LOG_WARN("No display registered");
+        LV_PROFILER_REFR_END;
+        return;
+    }
+
+    lv_draw_buf_t * buf_act = disp_refr->buf_act;
+    if(!(buf_act && buf_act->data && buf_act->data_size)) {
+        LV_LOG_WARN("No draw buffer");
+        LV_PROFILER_REFR_END;
+        return;
+    }
+
+    lv_result_t res = lv_display_send_event(disp_refr, LV_EVENT_REFR_START, NULL);
+    if(res == LV_RESULT_INVALID) {
+        LV_TRACE_REFR("deleted");
+        LV_PROFILER_REFR_END;
+        return;
+    }
+
+    /*Refresh the screen's layout if required*/
+    LV_PROFILER_LAYOUT_BEGIN_TAG("layout");
+    lv_obj_update_layout(disp_refr->act_scr);
+    if(disp_refr->prev_scr) lv_obj_update_layout(disp_refr->prev_scr);
+
+    lv_obj_update_layout(disp_refr->bottom_layer);
+    lv_obj_update_layout(disp_refr->top_layer);
+    lv_obj_update_layout(disp_refr->sys_layer);
+    LV_PROFILER_LAYOUT_END_TAG("layout");
+
+    /*Do nothing if there is no active screen*/
+    if(disp_refr->act_scr == NULL) {
+        disp_refr->inv_p = 0;
+        LV_LOG_WARN("there is no active screen");
+        goto refr_finish;
+    }
+
+    lv_refr_join_area();
+    refr_sync_areas();
+    refr_invalid_areas();
+
+    if(disp_refr->inv_p == 0) goto refr_finish;
+    /*In double buffered direct mode save the updated areas.
+     *They will be used on the next call to synchronize the buffers.*/
+    if(lv_display_is_double_buffered(disp_refr) && disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_DIRECT) {
+        uint32_t i;
+        for(i = 0; i < disp_refr->inv_p; i++) {
+            if(disp_refr->inv_area_joined[i])
+                continue;
+
+            lv_area_t * sync_area = lv_ll_ins_tail(&disp_refr->sync_areas);
+            *sync_area = disp_refr->inv_areas[i];
+        }
+    }
+
+    lv_memzero(disp_refr->inv_areas, sizeof(disp_refr->inv_areas));
+    lv_memzero(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined));
+    disp_refr->inv_p = 0;
+
+refr_finish:
+
+#if LV_DRAW_SW_COMPLEX == 1
+    lv_draw_sw_mask_cleanup();
+#endif
+
+    lv_display_send_event(disp_refr, LV_EVENT_REFR_READY, NULL);
+
+    LV_TRACE_REFR("finished");
+    LV_PROFILER_REFR_END;
+}
+
+/**
+ * Search the most top object which fully covers an area
+ * @param area_p pointer to an area
+ * @param obj the first object to start the searching (typically a screen)
+ * @return
+ */
+lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
+{
+    lv_obj_t * found_p = NULL;
+
+    if(lv_area_is_in(area_p, &obj->coords, 0) == false) return NULL;
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return NULL;
+    if(lv_obj_get_layer_type(obj) != LV_LAYER_TYPE_NONE) return NULL;
+    if(lv_obj_get_style_opa(obj, LV_PART_MAIN) < LV_OPA_MAX) return NULL;
+
+    /*If this object is fully cover the draw area then check the children too*/
+    lv_cover_check_info_t info;
+    info.res = LV_COVER_RES_COVER;
+    info.area = area_p;
+    lv_obj_send_event(obj, LV_EVENT_COVER_CHECK, &info);
+    if(info.res == LV_COVER_RES_MASKED) return NULL;
+
+    int32_t i;
+    int32_t child_cnt = lv_obj_get_child_count(obj);
+    for(i = child_cnt - 1; i >= 0; i--) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        found_p = lv_refr_get_top_obj(area_p, child);
+
+        /*If a children is ok then break*/
+        if(found_p != NULL) {
+            break;
+        }
+    }
+
+    /*If no better children use this object*/
+    if(found_p == NULL && info.res == LV_COVER_RES_COVER) {
+        found_p = obj;
+    }
+
+    return found_p;
+}
+
+
+void lv_obj_refr(lv_layer_t * layer, lv_obj_t * obj)
+{
+    LV_ASSERT_NULL(layer);
+    LV_ASSERT_NULL(obj);
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return;
+
+    /*If `opa_layered != LV_OPA_COVER` draw the widget on a new layer and blend that layer with the given opacity.*/
+    const lv_opa_t opa_layered = lv_obj_get_style_opa_layered(obj, LV_PART_MAIN);
+    if(opa_layered <= LV_OPA_MIN) return;
+
+    const lv_opa_t layer_opa_ori = layer->opa;
+    const lv_color32_t layer_recolor = layer->recolor;
+
+    /*Normal `opa` (not layered) will just scale down `bg_opa`, `text_opa`, etc, in the upcoming drawings.*/
+    const lv_opa_t opa_main = lv_obj_get_style_opa(obj, LV_PART_MAIN);
+    if(opa_main < LV_OPA_MAX) {
+        layer->opa = LV_OPA_MIX2(layer_opa_ori, opa_main);
+    }
+
+    layer->recolor = lv_obj_style_apply_recolor(obj, LV_PART_MAIN, layer->recolor);
+
+    lv_layer_type_t layer_type = lv_obj_get_layer_type(obj);
+    if(layer_type == LV_LAYER_TYPE_NONE) {
+        lv_obj_redraw(layer, obj);
+    }
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    /*If the layer opa is full then use the matrix transform*/
+    else if(opa_layered >= LV_OPA_MAX && !refr_check_obj_clip_overflow(layer, obj)) {
+        refr_obj_matrix(layer, obj);
+    }
+#endif /* LV_DRAW_TRANSFORM_USE_MATRIX */
+    else {
+        lv_area_t layer_area_full;
+        lv_area_t obj_draw_size;
+        lv_result_t res = layer_get_area(layer, obj, layer_type, &layer_area_full, &obj_draw_size);
+        if(res != LV_RESULT_OK) return;
+
+        /*Simple layers can be subdivided into smaller layers*/
+        uint32_t max_rgb_row_height = lv_area_get_height(&layer_area_full);
+        uint32_t max_argb_row_height = lv_area_get_height(&layer_area_full);
+        if(layer_type == LV_LAYER_TYPE_SIMPLE) {
+            int32_t w = lv_area_get_width(&layer_area_full);
+            uint8_t px_size = lv_color_format_get_size(disp_refr->color_format);
+            max_rgb_row_height = LV_DRAW_LAYER_SIMPLE_BUF_SIZE / w / px_size;
+            max_argb_row_height = LV_DRAW_LAYER_SIMPLE_BUF_SIZE / w / sizeof(lv_color32_t);
+        }
+
+        lv_area_t layer_area_act;
+        layer_area_act.x1 = layer_area_full.x1;
+        layer_area_act.x2 = layer_area_full.x2;
+        layer_area_act.y1 = layer_area_full.y1;
+        layer_area_act.y2 = layer_area_full.y1;
+
+        while(layer_area_act.y2 < layer_area_full.y2) {
+            /* Test with an RGB layer size (which is larger than the ARGB layer size)
+             * If it really doesn't need alpha use it. Else switch to the ARGB size*/
+            layer_area_act.y2 = layer_area_act.y1 + max_rgb_row_height - 1;
+            if(layer_area_act.y2 > layer_area_full.y2) layer_area_act.y2 = layer_area_full.y2;
+
+            const void * bitmap_mask_src = lv_obj_get_style_bitmap_mask_src(obj, LV_PART_MAIN);
+            bool area_need_alpha = bitmap_mask_src || alpha_test_area_on_obj(obj, &layer_area_act);
+
+            if(area_need_alpha) {
+                layer_area_act.y2 = layer_area_act.y1 + max_argb_row_height - 1;
+                if(layer_area_act.y2 > layer_area_full.y2) layer_area_act.y2 = layer_area_full.y2;
+            }
+
+            lv_layer_t * new_layer = lv_draw_layer_create(layer,
+                                                          area_need_alpha ? LV_COLOR_FORMAT_ARGB8888 : LV_COLOR_FORMAT_NATIVE, &layer_area_act);
+            lv_obj_redraw(new_layer, obj);
+
+            lv_point_t pivot = {
+                .x = lv_obj_get_style_transform_pivot_x(obj, LV_PART_MAIN),
+                .y = lv_obj_get_style_transform_pivot_y(obj, LV_PART_MAIN)
+            };
+
+            if(LV_COORD_IS_PCT(pivot.x)) {
+                pivot.x = (LV_COORD_GET_PCT(pivot.x) * lv_area_get_width(&obj->coords)) / 100;
+            }
+            if(LV_COORD_IS_PCT(pivot.y)) {
+                pivot.y = (LV_COORD_GET_PCT(pivot.y) * lv_area_get_height(&obj->coords)) / 100;
+            }
+
+            lv_draw_image_dsc_t layer_draw_dsc;
+            lv_draw_image_dsc_init(&layer_draw_dsc);
+            layer_draw_dsc.pivot.x = obj->coords.x1 + pivot.x - new_layer->buf_area.x1;
+            layer_draw_dsc.pivot.y = obj->coords.y1 + pivot.y - new_layer->buf_area.y1;
+
+            layer_draw_dsc.opa = opa_layered;
+            layer_draw_dsc.rotation = lv_obj_get_style_transform_rotation(obj, LV_PART_MAIN);
+            while(layer_draw_dsc.rotation > 3600) layer_draw_dsc.rotation -= 3600;
+            while(layer_draw_dsc.rotation < 0) layer_draw_dsc.rotation += 3600;
+            layer_draw_dsc.scale_x = lv_obj_get_style_transform_scale_x(obj, LV_PART_MAIN);
+            layer_draw_dsc.scale_y = lv_obj_get_style_transform_scale_y(obj, LV_PART_MAIN);
+            layer_draw_dsc.skew_x = lv_obj_get_style_transform_skew_x(obj, LV_PART_MAIN);
+            layer_draw_dsc.skew_y = lv_obj_get_style_transform_skew_y(obj, LV_PART_MAIN);
+            layer_draw_dsc.blend_mode = lv_obj_get_style_blend_mode(obj, LV_PART_MAIN);
+            layer_draw_dsc.antialias = disp_refr->antialiasing;
+            layer_draw_dsc.bitmap_mask_src = bitmap_mask_src;
+            layer_draw_dsc.image_area = obj_draw_size;
+            layer_draw_dsc.src = new_layer;
+
+            lv_draw_layer(layer, &layer_draw_dsc, &layer_area_act);
+
+            layer_area_act.y1 = layer_area_act.y2 + 1;
+        }
+    }
+
+    /* Restore the original layer opa and recolor */
+    layer->opa = layer_opa_ori;
+    layer->recolor = layer_recolor;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Join the areas which has got common parts
+ */
+static void lv_refr_join_area(void)
+{
+    LV_PROFILER_REFR_BEGIN;
+    uint32_t join_from;
+    uint32_t join_in;
+    lv_area_t joined_area;
+    for(join_in = 0; join_in < disp_refr->inv_p; join_in++) {
+        if(disp_refr->inv_area_joined[join_in] != 0) continue;
+
+        /*Check all areas to join them in 'join_in'*/
+        for(join_from = 0; join_from < disp_refr->inv_p; join_from++) {
+            /*Handle only unjoined areas and ignore itself*/
+            if(disp_refr->inv_area_joined[join_from] != 0 || join_in == join_from) {
+                continue;
+            }
+
+            /*Check if the areas are on each other*/
+            if(lv_area_is_on(&disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]) == false) {
+                continue;
+            }
+
+            lv_area_join(&joined_area, &disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]);
+
+            /*Join two area only if the joined area size is smaller*/
+            if(lv_area_get_size(&joined_area) < (lv_area_get_size(&disp_refr->inv_areas[join_in]) +
+                                                 lv_area_get_size(&disp_refr->inv_areas[join_from]))) {
+                lv_area_copy(&disp_refr->inv_areas[join_in], &joined_area);
+
+                /*Mark 'join_form' is joined into 'join_in'*/
+                disp_refr->inv_area_joined[join_from] = 1;
+            }
+        }
+    }
+    LV_PROFILER_REFR_END;
+}
+
+/**
+ * Refresh the sync areas
+ */
+static void refr_sync_areas(void)
+{
+    /*Do not sync if not direct or double buffered*/
+    if(disp_refr->render_mode != LV_DISPLAY_RENDER_MODE_DIRECT) return;
+
+    /*Do not sync if not double buffered*/
+    if(!lv_display_is_double_buffered(disp_refr)) return;
+
+    /*Do not sync if no sync areas*/
+    if(lv_ll_is_empty(&disp_refr->sync_areas)) return;
+
+    LV_PROFILER_REFR_BEGIN;
+    /*With double buffered direct mode synchronize the rendered areas to the other buffer*/
+    /*We need to wait for ready here to not mess up the active screen*/
+    wait_for_flushing(disp_refr);
+
+    /*The buffers are already swapped.
+     *So the active buffer is the off screen buffer where LVGL will render*/
+    lv_draw_buf_t * off_screen = disp_refr->buf_act;
+    /*Triple buffer sync buffer for off-screen2 updates.*/
+    lv_draw_buf_t * off_screen2;
+    lv_draw_buf_t * on_screen;
+
+    if(disp_refr->buf_act == disp_refr->buf_1) {
+        off_screen2 = disp_refr->buf_2;
+        on_screen = disp_refr->buf_3 ? disp_refr->buf_3 : disp_refr->buf_2;
+    }
+    else if(disp_refr->buf_act == disp_refr->buf_2) {
+        off_screen2 = disp_refr->buf_3 ? disp_refr->buf_3 : disp_refr->buf_1;
+        on_screen = disp_refr->buf_1;
+    }
+    else {
+        off_screen2 = disp_refr->buf_1;
+        on_screen = disp_refr->buf_2;
+    }
+
+    uint32_t hor_res = lv_display_get_horizontal_resolution(disp_refr);
+    uint32_t ver_res = lv_display_get_vertical_resolution(disp_refr);
+
+    /*Iterate through invalidated areas to see if sync area should be copied*/
+    uint16_t i;
+    int8_t j;
+    lv_area_t res[4] = {0};
+    int8_t res_c;
+    lv_area_t * sync_area, * new_area, * next_area;
+    for(i = 0; i < disp_refr->inv_p; i++) {
+        /*Skip joined areas*/
+        if(disp_refr->inv_area_joined[i]) continue;
+
+        /*Iterate over sync areas*/
+        sync_area = lv_ll_get_head(&disp_refr->sync_areas);
+        while(sync_area != NULL) {
+            /*Get next sync area*/
+            next_area = lv_ll_get_next(&disp_refr->sync_areas, sync_area);
+
+            /*Remove intersect of redraw area from sync area and get remaining areas*/
+            res_c = lv_area_diff(res, sync_area, &disp_refr->inv_areas[i]);
+
+            /*New sub areas created after removing intersect*/
+            if(res_c != -1) {
+                /*Replace old sync area with new areas*/
+                for(j = 0; j < res_c; j++) {
+                    new_area = lv_ll_ins_prev(&disp_refr->sync_areas, sync_area);
+                    *new_area = res[j];
+                }
+                lv_ll_remove(&disp_refr->sync_areas, sync_area);
+                lv_free(sync_area);
+            }
+
+            /*Move on to next sync area*/
+            sync_area = next_area;
+        }
+    }
+
+    lv_area_t disp_area = {0, 0, (int32_t)hor_res - 1, (int32_t)ver_res - 1};
+    /*Copy sync areas (if any remaining)*/
+    for(sync_area = lv_ll_get_head(&disp_refr->sync_areas); sync_area != NULL;
+        sync_area = lv_ll_get_next(&disp_refr->sync_areas, sync_area)) {
+        /**
+         * @todo Resize SDL window will trigger crash because of sync_area is larger than disp_area
+         */
+        if(!lv_area_intersect(sync_area, sync_area, &disp_area)) {
+            continue;
+        }
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+        if(lv_display_get_matrix_rotation(disp_refr)) {
+            lv_display_rotate_area(disp_refr, sync_area);
+        }
+#endif
+        lv_draw_buf_copy(off_screen, sync_area, on_screen, sync_area);
+        if(off_screen2 != on_screen)
+            lv_draw_buf_copy(off_screen2, sync_area, on_screen, sync_area);
+    }
+
+    /*Clear sync areas*/
+    lv_ll_clear(&disp_refr->sync_areas);
+    LV_PROFILER_REFR_END;
+}
+
+/**
+ * Refresh the joined areas
+ */
+static void refr_invalid_areas(void)
+{
+    if(disp_refr->inv_p == 0) return;
+    LV_PROFILER_REFR_BEGIN;
+
+    /*Notify the display driven rendering has started*/
+    lv_display_send_event(disp_refr, LV_EVENT_RENDER_START, NULL);
+
+    /*Find the last area which will be drawn*/
+    int32_t i;
+    int32_t last_i = 0;
+    for(i = disp_refr->inv_p - 1; i >= 0; i--) {
+        if(disp_refr->inv_area_joined[i] == 0) {
+            last_i = i;
+            break;
+        }
+    }
+
+    disp_refr->last_area = 0;
+    disp_refr->last_part = 0;
+    disp_refr->rendering_in_progress = true;
+
+    for(i = 0; i < (int32_t)disp_refr->inv_p; i++) {
+        /*Refresh the unjoined areas*/
+        if(disp_refr->inv_area_joined[i]) continue;
+
+        if(i == last_i) disp_refr->last_area = 1;
+        disp_refr->last_part = 0;
+
+        lv_area_t inv_a = disp_refr->inv_areas[i];
+        if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_PARTIAL) {
+            /*Calculate the max row num*/
+            int32_t w = lv_area_get_width(&inv_a);
+            int32_t h = lv_area_get_height(&inv_a);
+
+            int32_t max_row = get_max_row(disp_refr, w, h);
+
+            int32_t row;
+            int32_t row_last = 0;
+            lv_area_t sub_area;
+            sub_area.x1 = inv_a.x1;
+            sub_area.x2 = inv_a.x2;
+            int32_t y_off = 0;
+            for(row = inv_a.y1; row + max_row - 1 <= inv_a.y2; row += max_row) {
+                /*Calc. the next y coordinates of draw_buf*/
+                sub_area.y1 = row;
+                sub_area.y2 = row + max_row - 1;
+                if(sub_area.y2 > inv_a.y2) sub_area.y2 = inv_a.y2;
+                row_last = sub_area.y2;
+                if(inv_a.y2 == row_last) disp_refr->last_part = 1;
+                refr_area(&sub_area, y_off);
+                y_off += lv_area_get_height(&sub_area);
+                draw_buf_flush(disp_refr);
+            }
+
+            /*If the last y coordinates are not handled yet ...*/
+            if(inv_a.y2 != row_last) {
+                /*Calc. the next y coordinates of draw_buf*/
+                sub_area.y1 = row;
+                sub_area.y2 = inv_a.y2;
+                disp_refr->last_part = 1;
+                refr_area(&sub_area, y_off);
+                y_off += lv_area_get_height(&sub_area);
+                draw_buf_flush(disp_refr);
+            }
+        }
+        else if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_FULL ||
+                disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_DIRECT) {
+            disp_refr->last_part = 1;
+            refr_area(&disp_refr->inv_areas[i], 0);
+            draw_buf_flush(disp_refr);
+        }
+    }
+
+    lv_display_send_event(disp_refr, LV_EVENT_RENDER_READY, NULL);
+    disp_refr->rendering_in_progress = false;
+    LV_PROFILER_REFR_END;
+}
+
+/**
+ * Reshape the draw buffer if required
+ * @param layer  pointer to a layer which will be drawn
+ */
+static void layer_reshape_draw_buf(lv_layer_t * layer, uint32_t stride)
+{
+    lv_draw_buf_t * ret = lv_draw_buf_reshape(
+                              layer->draw_buf,
+                              layer->color_format,
+                              lv_area_get_width(&layer->buf_area),
+                              lv_area_get_height(&layer->buf_area),
+                              stride);
+    LV_UNUSED(ret);
+    LV_ASSERT_NULL(ret);
+}
+
+/**
+ * Refresh an area if there is Virtual Display Buffer
+ * @param area_p  pointer to an area to refresh
+ */
+static void refr_area(const lv_area_t * area_p, int32_t y_offset)
+{
+    LV_PROFILER_REFR_BEGIN;
+    lv_layer_t * layer = disp_refr->layer_head;
+    layer->draw_buf = disp_refr->buf_act;
+    layer->_clip_area = *area_p;
+    layer->phy_clip_area = *area_p;
+    layer->partial_y_offset = y_offset;
+
+    if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_PARTIAL) {
+        /*In partial mode render this area to the buffer*/
+        layer->buf_area = *area_p;
+        layer_reshape_draw_buf(layer, LV_STRIDE_AUTO);
+    }
+    else if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_DIRECT ||
+            disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_FULL) {
+        /*In direct mode and full mode the buffer area is always the whole screen, not considering rotation*/
+        layer->buf_area.x1 = 0;
+        layer->buf_area.y1 = 0;
+        if(lv_display_get_matrix_rotation(disp_refr)) {
+            layer->buf_area.x2 = lv_display_get_original_horizontal_resolution(disp_refr) - 1;
+            layer->buf_area.y2 = lv_display_get_original_vertical_resolution(disp_refr) - 1;
+        }
+        else {
+            layer->buf_area.x2 = lv_display_get_horizontal_resolution(disp_refr) - 1;
+            layer->buf_area.y2 = lv_display_get_vertical_resolution(disp_refr) - 1;
+        }
+        layer_reshape_draw_buf(layer, disp_refr->stride_is_auto ? LV_STRIDE_AUTO : layer->draw_buf->header.stride);
+    }
+
+    /*Try to divide the area to smaller tiles*/
+    uint32_t tile_cnt = 1;
+    int32_t tile_h = lv_area_get_height(area_p);
+    if(LV_COLOR_FORMAT_IS_INDEXED(layer->color_format) == false) {
+        /* Assume that the buffer size (can be screen sized or smaller in case of partial mode)
+         * and max tile size are the optimal scenario. From this calculate the ideal tile size
+         * and set the tile count and tile height accordingly.
+         */
+        uint32_t max_tile_cnt = disp_refr->tile_cnt;
+        uint32_t total_buf_size = layer->draw_buf->data_size;
+        uint32_t ideal_tile_size = total_buf_size / max_tile_cnt;
+        uint32_t area_buf_size = lv_area_get_size(area_p) * lv_color_format_get_size(layer->color_format);
+
+        tile_cnt = (area_buf_size + (ideal_tile_size - 1)) / ideal_tile_size; /*Round up*/
+        tile_h = lv_area_get_height(area_p) / tile_cnt;
+    }
+
+    if(tile_cnt == 1) {
+        refr_configured_layer(layer);
+    }
+    else {
+        /* Don't draw to the layers buffer of the display but create smaller dummy layers which are using the
+         * display's layer buffer. These will be the tiles. By using tiles it's more likely that there will
+         * be independent areas for each draw unit. */
+        lv_layer_t * tile_layers = lv_malloc(tile_cnt * sizeof(lv_layer_t));
+        LV_ASSERT_MALLOC(tile_layers);
+        if(tile_layers == NULL) {
+            disp_refr->refreshed_area = *area_p;
+            LV_PROFILER_REFR_END;
+            return;
+        }
+        uint32_t i;
+        for(i = 0; i < tile_cnt; i++) {
+            lv_area_t tile_area;
+            lv_area_set(&tile_area, area_p->x1, area_p->y1 + i * tile_h,
+                        area_p->x2, area_p->y1 + (i + 1) * tile_h - 1);
+
+            if(i == tile_cnt - 1) {
+                tile_area.y2 = area_p->y2;
+            }
+
+            lv_layer_t * tile_layer = &tile_layers[i];
+            lv_draw_layer_init(tile_layer, NULL, layer->color_format, &tile_area);
+            tile_layer->buf_area = layer->buf_area; /*the buffer is still large*/
+            tile_layer->draw_buf = layer->draw_buf;
+            refr_configured_layer(tile_layer);
+        }
+
+
+        /*Wait until all tiles are ready and destroy remove them*/
+        for(i = 0; i < tile_cnt; i++) {
+            lv_layer_t * tile_layer = &tile_layers[i];
+            while(tile_layer->draw_task_head) {
+                lv_draw_dispatch_wait_for_request();
+                lv_draw_dispatch();
+            }
+
+            lv_layer_t * layer_i = disp_refr->layer_head;
+            while(layer_i) {
+                if(layer_i->next == tile_layer) {
+                    layer_i->next = tile_layer->next;
+                    break;
+                }
+                layer_i = layer_i->next;
+            }
+
+            if(disp_refr->layer_deinit) disp_refr->layer_deinit(disp_refr, tile_layer);
+        }
+        lv_free(tile_layers);
+    }
+
+    disp_refr->refreshed_area = *area_p;
+    LV_PROFILER_REFR_END;
+}
+
+static void refr_configured_layer(lv_layer_t * layer)
+{
+    LV_PROFILER_REFR_BEGIN;
+
+    lv_layer_reset(layer);
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    if(lv_display_get_matrix_rotation(disp_refr)) {
+        const lv_display_rotation_t rotation = lv_display_get_rotation(disp_refr);
+        if(rotation != LV_DISPLAY_ROTATION_0) {
+            lv_display_rotate_area(disp_refr, &layer->phy_clip_area);
+
+            /**
+             * The screen rotation direction defined by LVGL is opposite to the drawing angle.
+             * Use direct matrix assignment to reduce precision loss and improve efficiency.
+             */
+            switch(rotation) {
+                case LV_DISPLAY_ROTATION_90:
+                    /**
+                     * lv_matrix_rotate(&layer->matrix, 270);
+                     * lv_matrix_translate(&layer->matrix, -disp_refr->ver_res, 0);
+                     */
+                    layer->matrix.m[0][0] = 0;
+                    layer->matrix.m[0][1] = 1;
+                    layer->matrix.m[0][2] = 0;
+                    layer->matrix.m[1][0] = -1;
+                    layer->matrix.m[1][1] = 0;
+                    layer->matrix.m[1][2] = disp_refr->ver_res;
+                    break;
+
+                case LV_DISPLAY_ROTATION_180:
+                    /**
+                     * lv_matrix_rotate(&layer->matrix, 180);
+                     * lv_matrix_translate(&layer->matrix, -disp_refr->hor_res, -disp_refr->ver_res);
+                     */
+                    layer->matrix.m[0][0] = -1;
+                    layer->matrix.m[0][1] = 0;
+                    layer->matrix.m[0][2] = disp_refr->hor_res;
+                    layer->matrix.m[1][0] = 0;
+                    layer->matrix.m[1][1] = -1;
+                    layer->matrix.m[1][2] = disp_refr->ver_res;
+                    break;
+
+                case LV_DISPLAY_ROTATION_270:
+                    /**
+                     * lv_matrix_rotate(&layer->matrix, 90);
+                     * lv_matrix_translate(&layer->matrix, 0, -disp_refr->hor_res);
+                     */
+                    layer->matrix.m[0][0] = 0;
+                    layer->matrix.m[0][1] = -1;
+                    layer->matrix.m[0][2] = disp_refr->hor_res;
+                    layer->matrix.m[1][0] = 1;
+                    layer->matrix.m[1][1] = 0;
+                    layer->matrix.m[1][2] = 0;
+                    break;
+
+                default:
+                    LV_LOG_WARN("Invalid rotation: %d", rotation);
+                    break;
+            }
+        }
+    }
+#endif /* LV_DRAW_TRANSFORM_USE_MATRIX */
+
+    /* In single buffered mode wait here until the buffer is freed.
+     * Else we would draw into the buffer while it's still being transferred to the display*/
+    if(!lv_display_is_double_buffered(disp_refr)) {
+        wait_for_flushing(disp_refr);
+    }
+    /*If the screen is transparent initialize it when the flushing is ready*/
+    if(lv_color_format_has_alpha(disp_refr->color_format)) {
+        lv_area_t clear_area = layer->_clip_area;
+        lv_area_move(&clear_area, -layer->buf_area.x1, -layer->buf_area.y1);
+        lv_draw_buf_clear(layer->draw_buf, &clear_area);
+    }
+
+    lv_obj_t * top_act_scr = NULL;
+    lv_obj_t * top_prev_scr = NULL;
+
+    /*Get the most top object which is not covered by others*/
+    top_act_scr = lv_refr_get_top_obj(&layer->_clip_area, lv_display_get_screen_active(disp_refr));
+    if(disp_refr->prev_scr) {
+        top_prev_scr = lv_refr_get_top_obj(&layer->_clip_area, disp_refr->prev_scr);
+    }
+
+    /*Draw a bottom layer background if there is no top object*/
+    if(top_act_scr == NULL && top_prev_scr == NULL) {
+        refr_obj_and_children(layer, lv_display_get_layer_bottom(disp_refr));
+    }
+
+    if(disp_refr->draw_prev_over_act) {
+        if(top_act_scr == NULL) top_act_scr = disp_refr->act_scr;
+        refr_obj_and_children(layer, top_act_scr);
+
+        /*Refresh the previous screen if any*/
+        if(disp_refr->prev_scr) {
+            if(top_prev_scr == NULL) top_prev_scr = disp_refr->prev_scr;
+            refr_obj_and_children(layer, top_prev_scr);
+        }
+    }
+    else {
+        /*Refresh the previous screen if any*/
+        if(disp_refr->prev_scr) {
+            if(top_prev_scr == NULL) top_prev_scr = disp_refr->prev_scr;
+            refr_obj_and_children(layer, top_prev_scr);
+        }
+
+        if(top_act_scr == NULL) top_act_scr = disp_refr->act_scr;
+        refr_obj_and_children(layer, top_act_scr);
+    }
+
+    /*Also refresh top and sys layer unconditionally*/
+    refr_obj_and_children(layer, lv_display_get_layer_top(disp_refr));
+    refr_obj_and_children(layer, lv_display_get_layer_sys(disp_refr));
+
+    LV_PROFILER_REFR_END;
+}
+
+/**
+ * Make the refreshing from an object. Draw all its children and the youngers too.
+ * @param top_p pointer to an objects. Start the drawing from it.
+ * @param mask_p pointer to an area, the objects will be drawn only here
+ */
+static void refr_obj_and_children(lv_layer_t * layer, lv_obj_t * top_obj)
+{
+    /*Normally always will be a top_obj (at least the screen)
+     *but in special cases (e.g. if the screen has alpha) it won't.
+     *In this case use the screen directly*/
+    if(top_obj == NULL) top_obj = lv_display_get_screen_active(disp_refr);
+    if(top_obj == NULL) return;  /*Shouldn't happen*/
+
+    LV_PROFILER_REFR_BEGIN;
+    /*Draw the 'younger' sibling objects because they can be on top_obj*/
+    lv_obj_t * parent;
+    lv_obj_t * border_p = top_obj;
+
+    parent = lv_obj_get_parent(top_obj);
+
+    /*Calculate the recolor before the parent*/
+    if(parent) {
+        layer->recolor = lv_obj_get_style_recolor_recursive(parent, LV_PART_MAIN);
+    }
+
+    /*Refresh the top object and its children*/
+    lv_obj_refr(layer, top_obj);
+
+    /*Do until not reach the screen*/
+    while(parent != NULL) {
+        bool go = false;
+        uint32_t i;
+        uint32_t child_cnt = lv_obj_get_child_count(parent);
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = parent->spec_attr->children[i];
+            if(!go) {
+                if(child == border_p) go = true;
+            }
+            else {
+                /*Refresh the objects*/
+                lv_obj_refr(layer, child);
+            }
+        }
+
+        /*Call the post draw function of the parents of the to object*/
+        lv_obj_send_event(parent, LV_EVENT_DRAW_POST_BEGIN, (void *)layer);
+        lv_obj_send_event(parent, LV_EVENT_DRAW_POST, (void *)layer);
+        lv_obj_send_event(parent, LV_EVENT_DRAW_POST_END, (void *)layer);
+
+        /*The new border will be the last parents,
+         *so the 'younger' brothers of parent will be refreshed*/
+        border_p = parent;
+        /*Go a level deeper*/
+        parent = lv_obj_get_parent(parent);
+    }
+    LV_PROFILER_REFR_END;
+}
+
+static lv_result_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type_t layer_type,
+                                  lv_area_t * layer_area_out, lv_area_t * obj_draw_size_out)
+{
+    int32_t ext_draw_size = lv_obj_get_ext_draw_size(obj);
+    lv_obj_get_coords(obj, obj_draw_size_out);
+    lv_area_increase(obj_draw_size_out, ext_draw_size, ext_draw_size);
+
+    if(layer_type == LV_LAYER_TYPE_TRANSFORM) {
+        /*Get the transformed area and clip it to the current clip area.
+         *This area needs to be updated on the screen.*/
+        lv_area_t clip_coords_for_obj;
+        lv_area_t tranf_coords = *obj_draw_size_out;
+        lv_obj_get_transformed_area(obj, &tranf_coords, LV_OBJ_POINT_TRANSFORM_FLAG_NONE);
+        if(!lv_area_intersect(&clip_coords_for_obj, &layer->_clip_area, &tranf_coords)) {
+            return LV_RESULT_INVALID;
+        }
+
+        /*Transform back (inverse) the transformed area.
+         *It will tell which area of the non-transformed widget needs to be redrawn
+         *in order to cover transformed area after transformation.*/
+        lv_area_t inverse_clip_coords_for_obj = clip_coords_for_obj;
+        lv_obj_get_transformed_area(obj, &inverse_clip_coords_for_obj, LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE);
+        if(!lv_area_intersect(&inverse_clip_coords_for_obj, &inverse_clip_coords_for_obj, obj_draw_size_out)) {
+            return LV_RESULT_INVALID;
+        }
+
+        *layer_area_out = inverse_clip_coords_for_obj;
+        lv_area_increase(layer_area_out, 5, 5); /*To avoid rounding error*/
+    }
+    else if(layer_type == LV_LAYER_TYPE_SIMPLE) {
+        lv_area_t clip_coords_for_obj;
+        if(!lv_area_intersect(&clip_coords_for_obj, &layer->_clip_area, obj_draw_size_out)) {
+            return LV_RESULT_INVALID;
+        }
+        *layer_area_out = clip_coords_for_obj;
+    }
+    else {
+        LV_LOG_WARN("Unhandled layer type");
+        return LV_RESULT_INVALID;
+    }
+
+    return LV_RESULT_OK;
+}
+
+static bool alpha_test_area_on_obj(lv_obj_t * obj, const lv_area_t * area)
+{
+    /*Test for alpha by assuming there is no alpha. If it fails, fall back to rendering with alpha*/
+    /*If the layer area is not fully on the object, it can't fully cover it*/
+    if(!lv_area_is_on(area, &obj->coords)) return true;
+
+    lv_cover_check_info_t info;
+    info.res = LV_COVER_RES_COVER;
+    info.area = area;
+    lv_obj_send_event(obj, LV_EVENT_COVER_CHECK, &info);
+    if(info.res == LV_COVER_RES_COVER) return false;
+    else return true;
+}
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+
+static bool obj_get_matrix(lv_obj_t * obj, lv_matrix_t * matrix)
+{
+    lv_matrix_identity(matrix);
+
+    const lv_matrix_t * obj_matrix = lv_obj_get_transform(obj);
+    if(obj_matrix) {
+        lv_matrix_translate(matrix, obj->coords.x1, obj->coords.y1);
+        lv_matrix_multiply(matrix, obj_matrix);
+        lv_matrix_translate(matrix, -obj->coords.x1, -obj->coords.y1);
+        return true;
+    }
+
+    lv_point_t pivot = {
+        .x = lv_obj_get_style_transform_pivot_x(obj, LV_PART_MAIN),
+        .y = lv_obj_get_style_transform_pivot_y(obj, LV_PART_MAIN)
+    };
+
+    pivot.x = obj->coords.x1 + lv_pct_to_px(pivot.x, lv_area_get_width(&obj->coords));
+    pivot.y = obj->coords.y1 + lv_pct_to_px(pivot.y, lv_area_get_height(&obj->coords));
+
+    int32_t rotation = lv_obj_get_style_transform_rotation(obj, LV_PART_MAIN);
+    int32_t scale_x = lv_obj_get_style_transform_scale_x(obj, LV_PART_MAIN);
+    int32_t scale_y = lv_obj_get_style_transform_scale_y(obj, LV_PART_MAIN);
+    int32_t skew_x = lv_obj_get_style_transform_skew_x(obj, LV_PART_MAIN);
+    int32_t skew_y = lv_obj_get_style_transform_skew_y(obj, LV_PART_MAIN);
+
+    if(scale_x <= 0 || scale_y <= 0) {
+        /* NOT draw if scale is negative or zero */
+        return false;
+    }
+
+    /* generate the obj matrix */
+    lv_matrix_translate(matrix, pivot.x, pivot.y);
+    if(rotation != 0) {
+        lv_matrix_rotate(matrix, rotation * 0.1f);
+    }
+
+    if(scale_x != LV_SCALE_NONE || scale_y != LV_SCALE_NONE) {
+        lv_matrix_scale(
+            matrix,
+            (float)scale_x / LV_SCALE_NONE,
+            (float)scale_y / LV_SCALE_NONE
+        );
+    }
+
+    if(skew_x != 0 || skew_y != 0) {
+        lv_matrix_skew(matrix, skew_x, skew_y);
+    }
+
+    lv_matrix_translate(matrix, -pivot.x, -pivot.y);
+    return true;
+}
+
+static void refr_obj_matrix(lv_layer_t * layer, lv_obj_t * obj)
+{
+    LV_PROFILER_REFR_BEGIN;
+    lv_matrix_t obj_matrix;
+    if(!obj_get_matrix(obj, &obj_matrix)) {
+        /* NOT draw if obj matrix is not available */
+        LV_PROFILER_REFR_END;
+        return;
+    }
+
+    lv_matrix_t matrix_inv;
+    if(!lv_matrix_inverse(&matrix_inv, &obj_matrix)) {
+        /* NOT draw if matrix is not invertible */
+        LV_PROFILER_REFR_END;
+        return;
+    }
+
+    /* save original matrix */
+    lv_matrix_t ori_matrix = layer->matrix;
+
+    /* apply the obj matrix */
+    lv_matrix_multiply(&layer->matrix, &obj_matrix);
+
+    /* calculate clip area without transform */
+    lv_area_t clip_area = layer->_clip_area;
+    lv_area_t clip_area_ori = layer->_clip_area;
+    clip_area = lv_matrix_transform_area(&matrix_inv, &clip_area);
+
+    /* increase the clip area by 1 pixel to avoid rounding errors */
+    if(!lv_matrix_is_identity_or_translation(&obj_matrix)) {
+        lv_area_increase(&clip_area, 1, 1);
+    }
+
+    layer->_clip_area = clip_area;
+
+    /* redraw obj */
+    lv_obj_redraw(layer, obj);
+
+    /* restore original matrix */
+    layer->matrix = ori_matrix;
+    /* restore clip area */
+    layer->_clip_area = clip_area_ori;
+    LV_PROFILER_REFR_END;
+}
+
+static bool refr_check_obj_clip_overflow(lv_layer_t * layer, lv_obj_t * obj)
+{
+    if(lv_obj_get_style_transform_rotation(obj, LV_PART_MAIN) == 0) {
+        return false;
+    }
+
+    /*Truncate the area to the object*/
+    lv_area_t obj_coords;
+    int32_t ext_size = lv_obj_get_ext_draw_size(obj);
+    lv_area_copy(&obj_coords, &obj->coords);
+    lv_area_increase(&obj_coords, ext_size, ext_size);
+
+    lv_obj_get_transformed_area(obj, &obj_coords, LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE);
+
+    lv_area_t clip_coords_for_obj;
+    if(!lv_area_intersect(&clip_coords_for_obj, &layer->_clip_area, &obj_coords)) {
+        return false;
+    }
+
+    bool has_clip = lv_memcmp(&clip_coords_for_obj, &obj_coords, sizeof(lv_area_t)) != 0;
+    return has_clip;
+}
+
+#endif /* LV_DRAW_TRANSFORM_USE_MATRIX */
+
+static uint32_t get_max_row(lv_display_t * disp, int32_t area_w, int32_t area_h)
+{
+    lv_color_format_t cf = disp->color_format;
+    uint32_t stride = lv_draw_buf_width_to_stride(area_w, cf);
+    uint32_t overhead = LV_COLOR_INDEXED_PALETTE_SIZE(cf) * sizeof(lv_color32_t);
+
+    if(stride == 0) {
+        LV_LOG_WARN("Invalid stride. Value is 0");
+        return 0;
+    }
+
+    int32_t max_row = (uint32_t)(disp->buf_act->data_size - overhead) / stride;
+
+    if(max_row > area_h) max_row = area_h;
+
+    /*Round down the lines of draw_buf if rounding is added*/
+    lv_area_t tmp;
+    tmp.x1 = 0;
+    tmp.x2 = 0;
+    tmp.y1 = 0;
+
+    int32_t h_tmp = max_row;
+    do {
+        tmp.y2 = h_tmp - 1;
+        lv_display_send_event(disp_refr, LV_EVENT_INVALIDATE_AREA, &tmp);
+
+        /*If this height fits into `max_row` then fine*/
+        if(lv_area_get_height(&tmp) <= max_row) break;
+
+        /*Decrement the height of the area until it fits into `max_row` after rounding*/
+        h_tmp--;
+    } while(h_tmp > 0);
+
+    if(h_tmp <= 0) {
+        LV_LOG_WARN("Can't set draw_buf height using the round function. (Wrong round_cb or too "
+                    "small draw_buf)");
+        return 0;
+    }
+    else {
+        max_row = tmp.y2 + 1;
+    }
+
+    return max_row;
+}
+
+/**
+ * Flush the content of the draw buffer
+ */
+static void draw_buf_flush(lv_display_t * disp)
+{
+    /*Flush the rendered content to the display*/
+    lv_layer_t * layer = disp->layer_head;
+
+    while(layer->draw_task_head) {
+        lv_draw_dispatch_wait_for_request();
+        lv_draw_dispatch();
+    }
+
+    /* In double buffered mode wait until the other buffer is freed
+     * and driver is ready to receive the new buffer.
+     * If we need to wait here it means that the content of one buffer is being sent to display
+     * and other buffer already contains the new rendered image. */
+    if(lv_display_is_double_buffered(disp)) {
+        wait_for_flushing(disp_refr);
+    }
+
+    disp->flushing = 1;
+
+    if(disp->last_area && disp->last_part) disp->flushing_last = 1;
+    else disp->flushing_last = 0;
+
+    bool flushing_last = disp->flushing_last;
+
+    if(disp->flush_cb) {
+        call_flush_cb(disp, &disp->refreshed_area, layer->draw_buf->data);
+    }
+    /*If there are 2 buffers swap them. With direct mode swap only on the last area*/
+    if(lv_display_is_double_buffered(disp) && (disp->render_mode != LV_DISPLAY_RENDER_MODE_DIRECT || flushing_last)) {
+        if(disp->buf_act == disp->buf_1) {
+            disp->buf_act = disp->buf_2;
+        }
+        else if(disp->buf_act == disp->buf_2) {
+            disp->buf_act = disp->buf_3 ? disp->buf_3 : disp->buf_1;
+        }
+        else {
+            disp->buf_act = disp->buf_1;
+        }
+    }
+}
+
+static void call_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map)
+{
+    LV_PROFILER_REFR_BEGIN;
+    LV_TRACE_REFR("Calling flush_cb on (%d;%d)(%d;%d) area with %p image pointer",
+                  (int)area->x1, (int)area->y1, (int)area->x2, (int)area->y2, (void *)px_map);
+
+    lv_area_t offset_area = {
+        .x1 = area->x1 + disp->offset_x,
+        .y1 = area->y1 + disp->offset_y,
+        .x2 = area->x2 + disp->offset_x,
+        .y2 = area->y2 + disp->offset_y
+    };
+
+    lv_display_send_event(disp, LV_EVENT_FLUSH_START, &offset_area);
+
+    /*For backward compatibility support LV_COLOR_16_SWAP (from v8)*/
+#if defined(LV_COLOR_16_SWAP) && LV_COLOR_16_SWAP
+    lv_draw_sw_rgb565_swap(px_map, lv_area_get_size(&offset_area));
+#endif
+
+    disp->flush_cb(disp, &offset_area, px_map);
+    lv_display_send_event(disp, LV_EVENT_FLUSH_FINISH, &offset_area);
+
+    LV_PROFILER_REFR_END;
+}
+
+static void wait_for_flushing(lv_display_t * disp)
+{
+    LV_PROFILER_REFR_BEGIN;
+    LV_LOG_TRACE("begin");
+
+    lv_display_send_event(disp, LV_EVENT_FLUSH_WAIT_START, NULL);
+
+    if(disp->flush_wait_cb) {
+        if(disp->flushing) {
+            disp->flush_wait_cb(disp);
+            disp->flushing = 0;
+        }
+    }
+    else {
+        while(disp->flushing);
+    }
+    disp->flushing_last = 0;
+
+    lv_display_send_event(disp, LV_EVENT_FLUSH_WAIT_FINISH, NULL);
+
+    LV_LOG_TRACE("end");
+    LV_PROFILER_REFR_END;
+}

components/easylvgl/lvgl9/src/core/lv_refr.h

@@ -0,0 +1,74 @@
+/**
+ * @file lv_refr.h
+ *
+ */
+
+#ifndef LV_REFR_H
+#define LV_REFR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj.h"
+#include "../display/lv_display.h"
+#include "../misc/lv_types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Redraw the invalidated areas now.
+ * Normally the redrawing is periodically executed in `lv_timer_handler` but a long blocking process
+ * can prevent the call of `lv_timer_handler`. In this case if the GUI is updated in the process
+ * (e.g. progress bar) this function can be called when the screen should be updated.
+ * @param disp pointer to display to refresh. NULL to refresh all displays.
+ */
+void lv_refr_now(lv_display_t * disp);
+
+/**
+ * Redrawn on object and all its children using the passed draw context
+ * @param layer pointer to a layer where to draw.
+ * @param obj   the start object from the redraw should start
+ */
+void lv_obj_redraw(lv_layer_t * layer, lv_obj_t * obj);
+
+/**
+ * Called periodically to handle the refreshing
+ * @param timer pointer to the timer itself, or `NULL`
+ */
+void lv_display_refr_timer(lv_timer_t * timer);
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_REFR_H*/

components/easylvgl/lvgl9/src/core/lv_refr_private.h

@@ -0,0 +1,84 @@
+/**
+ * @file lv_refr_private.h
+ *
+ */
+
+#ifndef LV_REFR_PRIVATE_H
+#define LV_REFR_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_refr.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the screen refresh subsystem
+ */
+void lv_refr_init(void);
+
+/**
+ * Deinitialize the screen refresh subsystem
+ */
+void lv_refr_deinit(void);
+
+/**
+ * Invalidate an area on display to redraw it
+ * @param area_p pointer to area which should be invalidated (NULL: delete the invalidated areas)
+ * @param disp pointer to display where the area should be invalidated (NULL can be used if there is
+ * only one display)
+ */
+void lv_inv_area(lv_display_t * disp, const lv_area_t * area_p);
+
+/**
+ * Get the display which is being refreshed
+ * @return the display being refreshed
+ */
+lv_display_t * lv_refr_get_disp_refreshing(void);
+
+/**
+ * Set the display which is being refreshed
+ * @param disp the display being refreshed
+ */
+void lv_refr_set_disp_refreshing(lv_display_t * disp);
+
+/**
+ * Search the most top object which fully covers an area
+ * @param area_p pointer to an area
+ * @param obj the first object to start the searching (typically a screen)
+ * @return
+ */
+lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj);
+
+/**
+ * Render an object to a layer
+ * @param layer target drawing layer
+ * @param obj   object to render
+ */
+void lv_obj_refr(lv_layer_t * layer, lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_REFR_PRIVATE_H*/

components/easylvgl/lvgl9/src/display/lv_display.c

@@ -0,0 +1,1372 @@
+/**
+ * @file lv_display.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../display/lv_display_private.h"
+#include "../misc/lv_event_private.h"
+#include "../misc/lv_anim_private.h"
+#include "../draw/lv_draw_private.h"
+#include "../core/lv_obj_private.h"
+#include "lv_display.h"
+#include "../misc/lv_math.h"
+#include "../core/lv_refr_private.h"
+#include "../stdlib/lv_string.h"
+#include "../themes/lv_theme.h"
+#include "../core/lv_global.h"
+#include "../others/sysmon/lv_sysmon.h"
+
+#if LV_USE_DRAW_SW
+    #include "../draw/sw/lv_draw_sw.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+#define disp_def LV_GLOBAL_DEFAULT()->disp_default
+#define disp_ll_p &(LV_GLOBAL_DEFAULT()->disp_ll)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_data);
+static void update_resolution(lv_display_t * disp);
+static void scr_load_internal(lv_obj_t * scr);
+static void scr_load_anim_start(lv_anim_t * a);
+static void opa_scale_anim(void * obj, int32_t v);
+static void set_x_anim(void * obj, int32_t v);
+static void set_y_anim(void * obj, int32_t v);
+static void scr_anim_completed(lv_anim_t * a);
+static bool is_out_anim(lv_screen_load_anim_t a);
+static void disp_event_cb(lv_event_t * e);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_display_t * lv_display_create(int32_t hor_res, int32_t ver_res)
+{
+    lv_display_t * disp = lv_ll_ins_head(disp_ll_p);
+    LV_ASSERT_MALLOC(disp);
+    if(!disp) return NULL;
+
+    lv_memzero(disp, sizeof(lv_display_t));
+
+    disp->hor_res          = hor_res;
+    disp->ver_res          = ver_res;
+    disp->physical_hor_res = -1;
+    disp->physical_ver_res = -1;
+    disp->offset_x         = 0;
+    disp->offset_y         = 0;
+    disp->antialiasing     = LV_COLOR_DEPTH > 8 ? 1 : 0;
+    disp->dpi              = LV_DPI_DEF;
+    disp->color_format = LV_COLOR_FORMAT_NATIVE;
+
+
+#if defined(LV_DRAW_SW_DRAW_UNIT_CNT) && (LV_DRAW_SW_DRAW_UNIT_CNT != 0)
+    disp->tile_cnt = LV_DRAW_SW_DRAW_UNIT_CNT;
+#else
+    disp->tile_cnt = 1;
+#endif
+
+    disp->layer_head = lv_malloc(sizeof(lv_layer_t));
+    LV_ASSERT_MALLOC(disp->layer_head);
+    if(disp->layer_head == NULL) return NULL;
+    lv_layer_init(disp->layer_head);
+
+    if(disp->layer_init) disp->layer_init(disp, disp->layer_head);
+    disp->layer_head->buf_area.x1 = 0;
+    disp->layer_head->buf_area.y1 = 0;
+    disp->layer_head->buf_area.x2 = hor_res - 1;
+    disp->layer_head->buf_area.y2 = ver_res - 1;
+    disp->layer_head->color_format = disp->color_format;
+
+    disp->inv_en_cnt = 1;
+    disp->last_activity_time = lv_tick_get();
+
+    lv_ll_init(&disp->sync_areas, sizeof(lv_area_t));
+
+    lv_display_t * disp_def_tmp = disp_def;
+    disp_def                 = disp; /*Temporarily change the default screen to create the default screens on the
+                                        new display*/
+    /*Create a refresh timer*/
+    disp->refr_timer = lv_timer_create(lv_display_refr_timer, LV_DEF_REFR_PERIOD, disp);
+    LV_ASSERT_MALLOC(disp->refr_timer);
+    if(disp->refr_timer == NULL) {
+        lv_free(disp);
+        return NULL;
+    }
+
+#if LV_USE_THEME_DEFAULT
+    if(lv_theme_default_is_inited() == false) {
+        disp->theme = lv_theme_default_init(disp, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED),
+                                            LV_THEME_DEFAULT_DARK, LV_FONT_DEFAULT);
+    }
+    else {
+        disp->theme = lv_theme_default_get();
+    }
+#elif LV_USE_THEME_SIMPLE
+    if(lv_theme_simple_is_inited() == false) {
+        disp->theme = lv_theme_simple_init(disp);
+    }
+    else {
+        disp->theme = lv_theme_simple_get();
+    }
+#elif LV_USE_THEME_MONO
+    if(lv_theme_mono_is_inited() == false) {
+        disp->theme = lv_theme_mono_init(disp, false, LV_FONT_DEFAULT);
+    }
+    else {
+        disp->theme = lv_theme_mono_get();
+    }
+#endif
+
+    disp->bottom_layer = lv_obj_create(NULL); /*Create bottom layer on the display*/
+    disp->act_scr   = lv_obj_create(NULL); /*Create a default screen on the display*/
+    disp->top_layer = lv_obj_create(NULL); /*Create top layer on the display*/
+    disp->sys_layer = lv_obj_create(NULL); /*Create sys layer on the display*/
+    lv_obj_remove_style_all(disp->bottom_layer);
+    lv_obj_remove_style_all(disp->top_layer);
+    lv_obj_remove_style_all(disp->sys_layer);
+    lv_obj_remove_flag(disp->top_layer, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(disp->sys_layer, LV_OBJ_FLAG_CLICKABLE);
+
+    lv_obj_set_scrollbar_mode(disp->bottom_layer, LV_SCROLLBAR_MODE_OFF);
+    lv_obj_set_scrollbar_mode(disp->top_layer, LV_SCROLLBAR_MODE_OFF);
+    lv_obj_set_scrollbar_mode(disp->sys_layer, LV_SCROLLBAR_MODE_OFF);
+
+    lv_obj_invalidate(disp->act_scr);
+
+    disp_def = disp_def_tmp; /*Revert the default display*/
+    if(disp_def == NULL) disp_def = disp; /*Initialize the default display*/
+
+    lv_display_add_event_cb(disp, disp_event_cb, LV_EVENT_REFR_REQUEST, NULL);
+
+    lv_timer_ready(disp->refr_timer); /*Be sure the screen will be refreshed immediately on start up*/
+
+#if LV_USE_PERF_MONITOR
+    lv_sysmon_show_performance(disp);
+#endif
+
+#if LV_USE_MEM_MONITOR
+    lv_sysmon_show_memory(disp);
+#endif
+
+    return disp;
+}
+
+void lv_display_delete(lv_display_t * disp)
+{
+    bool was_default = false;
+    bool was_refr = false;
+    if(disp == lv_display_get_default()) was_default = true;
+    if(disp == lv_refr_get_disp_refreshing()) was_refr = true;
+
+    lv_display_send_event(disp, LV_EVENT_DELETE, NULL);
+    lv_event_mark_deleted(disp);
+    lv_event_remove_all(&(disp->event_list));
+
+    /*Detach the input devices*/
+    lv_indev_t * indev;
+    indev = lv_indev_get_next(NULL);
+    while(indev) {
+        if(lv_indev_get_display(indev) == disp) {
+            lv_indev_set_display(indev, NULL);
+        }
+        indev = lv_indev_get_next(indev);
+    }
+
+    /* Delete screen and other obj */
+    if(disp->sys_layer) {
+        lv_obj_delete(disp->sys_layer);
+        disp->sys_layer = NULL;
+    }
+    if(disp->top_layer) {
+        lv_obj_delete(disp->top_layer);
+        disp->top_layer = NULL;
+    }
+
+    if(disp->bottom_layer) {
+        lv_obj_delete(disp->bottom_layer);
+        disp->bottom_layer = NULL;
+    }
+
+    disp->act_scr = NULL;
+
+    while(disp->screen_cnt != 0) {
+        /*Delete the screens*/
+        lv_obj_delete(disp->screens[0]);
+    }
+
+    lv_ll_clear(&disp->sync_areas);
+    lv_ll_remove(disp_ll_p, disp);
+    if(disp->refr_timer) lv_timer_delete(disp->refr_timer);
+
+    if(disp->layer_deinit) disp->layer_deinit(disp, disp->layer_head);
+    lv_free(disp->layer_head);
+
+    lv_free(disp);
+
+    if(was_default) lv_display_set_default(lv_ll_get_head(disp_ll_p));
+
+    if(was_refr) lv_refr_set_disp_refreshing(NULL);
+}
+
+void lv_display_set_default(lv_display_t * disp)
+{
+    disp_def = disp;
+}
+
+lv_display_t * lv_display_get_default(void)
+{
+    return disp_def;
+}
+
+lv_display_t * lv_display_get_next(lv_display_t * disp)
+{
+    if(disp == NULL)
+        return lv_ll_get_head(disp_ll_p);
+    else
+        return lv_ll_get_next(disp_ll_p, disp);
+}
+
+/*---------------------
+ * RESOLUTION
+ *--------------------*/
+
+void lv_display_set_resolution(lv_display_t * disp, int32_t hor_res, int32_t ver_res)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    if(disp->hor_res == hor_res && disp->ver_res == ver_res) return;
+
+    disp->hor_res = hor_res;
+    disp->ver_res = ver_res;
+
+    update_resolution(disp);
+}
+
+void lv_display_set_physical_resolution(lv_display_t * disp, int32_t hor_res, int32_t ver_res)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->physical_hor_res = hor_res;
+    disp->physical_ver_res = ver_res;
+
+    lv_obj_invalidate(disp->sys_layer);
+
+}
+
+void lv_display_set_offset(lv_display_t * disp, int32_t x, int32_t y)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->offset_x = x;
+    disp->offset_y = y;
+
+    lv_obj_invalidate(disp->sys_layer);
+
+}
+
+void lv_display_set_dpi(lv_display_t * disp, int32_t dpi)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->dpi = dpi;
+}
+
+int32_t lv_display_get_horizontal_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+            case LV_DISPLAY_ROTATION_270:
+                return disp->ver_res;
+            default:
+                return disp->hor_res;
+        }
+    }
+}
+
+int32_t lv_display_get_vertical_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+            case LV_DISPLAY_ROTATION_270:
+                return disp->hor_res;
+            default:
+                return disp->ver_res;
+        }
+    }
+}
+
+int32_t lv_display_get_original_horizontal_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) {
+        return 0;
+    }
+
+    return disp->hor_res;
+}
+
+int32_t lv_display_get_original_vertical_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) {
+        return 0;
+    }
+
+    return disp->ver_res;
+}
+
+int32_t lv_display_get_physical_horizontal_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+            case LV_DISPLAY_ROTATION_270:
+                return disp->physical_ver_res > 0 ? disp->physical_ver_res : disp->ver_res;
+            default:
+                return disp->physical_hor_res > 0 ? disp->physical_hor_res : disp->hor_res;
+        }
+    }
+}
+
+int32_t lv_display_get_physical_vertical_resolution(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+            case LV_DISPLAY_ROTATION_270:
+                return disp->physical_hor_res > 0 ? disp->physical_hor_res : disp->hor_res;
+            default:
+                return disp->physical_ver_res > 0 ? disp->physical_ver_res : disp->ver_res;
+        }
+    }
+}
+
+int32_t lv_display_get_offset_x(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+                return disp->offset_y;
+            case LV_DISPLAY_ROTATION_180:
+                return lv_display_get_physical_horizontal_resolution(disp) - disp->offset_x;
+            case LV_DISPLAY_ROTATION_270:
+                return lv_display_get_physical_horizontal_resolution(disp) - disp->offset_y;
+            default:
+                return disp->offset_x;
+        }
+    }
+}
+
+int32_t lv_display_get_offset_y(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->rotation) {
+            case LV_DISPLAY_ROTATION_90:
+                return disp->offset_x;
+            case LV_DISPLAY_ROTATION_180:
+                return lv_display_get_physical_vertical_resolution(disp) - disp->offset_y;
+            case LV_DISPLAY_ROTATION_270:
+                return lv_display_get_physical_vertical_resolution(disp) - disp->offset_x;
+            default:
+                return disp->offset_y;
+        }
+    }
+}
+
+int32_t lv_display_get_dpi(const lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return LV_DPI_DEF;  /*Do not return 0 because it might be a divider*/
+    return disp->dpi;
+}
+
+/*---------------------
+ * BUFFERING
+ *--------------------*/
+
+void lv_display_set_draw_buffers(lv_display_t * disp, lv_draw_buf_t * buf1, lv_draw_buf_t * buf2)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->buf_1 = buf1;
+    disp->buf_2 = buf2;
+    disp->buf_act = disp->buf_1;
+
+    disp->stride_is_auto = 0;
+}
+
+void lv_display_set_3rd_draw_buffer(lv_display_t * disp, lv_draw_buf_t * buf3)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    LV_ASSERT_MSG(disp->buf_1 != NULL, "buf1 is null");
+    LV_ASSERT_MSG(disp->buf_2 != NULL, "buf2 is null");
+
+    disp->buf_3 = buf3;
+}
+
+void lv_display_set_buffers(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size,
+                            lv_display_render_mode_t render_mode)
+{
+    LV_ASSERT_MSG(buf1 != NULL, "Null buffer");
+    lv_color_format_t cf = lv_display_get_color_format(disp);
+    uint32_t w = lv_display_get_original_horizontal_resolution(disp);
+    uint32_t h = lv_display_get_original_vertical_resolution(disp);
+    LV_ASSERT_MSG(w != 0 && h != 0, "display resolution is 0");
+
+    /* buf1 or buf2 is not aligned according to LV_DRAW_BUF_ALIGN */
+    LV_ASSERT_FORMAT_MSG(buf1 == lv_draw_buf_align(buf1, cf), "buf1 is not aligned: %p", buf1);
+    LV_ASSERT_FORMAT_MSG(buf2 == NULL || buf2 == lv_draw_buf_align(buf2, cf), "buf2 is not aligned: %p", buf2);
+
+    uint32_t stride = lv_draw_buf_width_to_stride(w, cf);
+    if(render_mode == LV_DISPLAY_RENDER_MODE_PARTIAL) {
+        LV_ASSERT_FORMAT_MSG(stride != 0, "stride is 0, check your color format %d and width: %" LV_PRIu32, cf, w);
+        /* for partial mode, we calculate the height based on the buf_size and stride */
+        h = buf_size / stride;
+        LV_ASSERT_MSG(h != 0, "the buffer is too small");
+    }
+    else {
+        LV_ASSERT_FORMAT_MSG(stride * h <= buf_size, "%s mode requires screen sized buffer(s)",
+                             render_mode == LV_DISPLAY_RENDER_MODE_FULL ? "FULL" : "DIRECT");
+    }
+
+    lv_draw_buf_init(&disp->_static_buf1, w, h, cf, stride, buf1, buf_size);
+    lv_draw_buf_init(&disp->_static_buf2, w, h, cf, stride, buf2, buf_size);
+    lv_display_set_draw_buffers(disp, &disp->_static_buf1, buf2 ? &disp->_static_buf2 : NULL);
+    lv_display_set_render_mode(disp, render_mode);
+
+    /* the stride was not set explicitly */
+    disp->stride_is_auto = 1;
+}
+
+void lv_display_set_buffers_with_stride(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size,
+                                        uint32_t stride, lv_display_render_mode_t render_mode)
+{
+    if(stride == LV_STRIDE_AUTO) {
+        lv_display_set_buffers(disp, buf1, buf2, buf_size, render_mode);
+        return;
+    }
+
+    LV_ASSERT_MSG(buf1 != NULL, "Null buffer");
+    lv_color_format_t cf = lv_display_get_color_format(disp);
+    uint32_t w = lv_display_get_original_horizontal_resolution(disp);
+    uint32_t h = lv_display_get_original_vertical_resolution(disp);
+    LV_ASSERT_MSG(w != 0 && h != 0, "display resolution is 0");
+
+    if(render_mode == LV_DISPLAY_RENDER_MODE_PARTIAL) {
+        /* for partial mode, we calculate the height based on the buf_size and stride */
+        h = buf_size / stride;
+        LV_ASSERT_MSG(h != 0, "the buffer is too small");
+    }
+    else {
+        LV_ASSERT_FORMAT_MSG(stride * h <= buf_size, "%s mode requires screen sized buffer(s)",
+                             render_mode == LV_DISPLAY_RENDER_MODE_FULL ? "FULL" : "DIRECT");
+    }
+
+    lv_draw_buf_init(&disp->_static_buf1, w, h, cf, stride, buf1, buf_size);
+    lv_draw_buf_init(&disp->_static_buf2, w, h, cf, stride, buf2, buf_size);
+    lv_display_set_draw_buffers(disp, &disp->_static_buf1, buf2 ? &disp->_static_buf2 : NULL);
+    lv_display_set_render_mode(disp, render_mode);
+
+    disp->stride_is_auto = 0;
+}
+
+void lv_display_set_render_mode(lv_display_t * disp, lv_display_render_mode_t render_mode)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+    disp->render_mode = render_mode;
+}
+
+void lv_display_set_flush_cb(lv_display_t * disp, lv_display_flush_cb_t flush_cb)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->flush_cb = flush_cb;
+}
+
+void lv_display_set_flush_wait_cb(lv_display_t * disp, lv_display_flush_wait_cb_t wait_cb)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->flush_wait_cb = wait_cb;
+}
+
+void lv_display_set_color_format(lv_display_t * disp, lv_color_format_t color_format)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->color_format = color_format;
+    disp->layer_head->color_format = color_format;
+    if(disp->buf_1) disp->buf_1->header.cf = color_format;
+    if(disp->buf_2) disp->buf_2->header.cf = color_format;
+    if(disp->buf_3) disp->buf_3->header.cf = color_format;
+
+    lv_display_send_event(disp, LV_EVENT_COLOR_FORMAT_CHANGED, NULL);
+}
+
+lv_color_format_t lv_display_get_color_format(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return LV_COLOR_FORMAT_UNKNOWN;
+
+    return disp->color_format;
+}
+
+void lv_display_set_tile_cnt(lv_display_t * disp, uint32_t tile_cnt)
+{
+    LV_ASSERT_FORMAT_MSG(tile_cnt < 256, "tile_cnt must be smaller than 256 (%" LV_PRId32 " was used)", tile_cnt);
+
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->tile_cnt = tile_cnt;
+}
+
+uint32_t lv_display_get_tile_cnt(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return 0;
+
+    return disp->tile_cnt;
+}
+
+void lv_display_set_antialiasing(lv_display_t * disp, bool en)
+{
+    LV_LOG_WARN("Disabling anti-aliasing is not supported since v9. This function will be removed.");
+
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->antialiasing = en;
+}
+
+bool lv_display_get_antialiasing(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return false;
+
+    return disp->antialiasing;
+}
+
+LV_ATTRIBUTE_FLUSH_READY void lv_display_flush_ready(lv_display_t * disp)
+{
+    disp->flushing = 0;
+}
+
+LV_ATTRIBUTE_FLUSH_READY bool lv_display_flush_is_last(lv_display_t * disp)
+{
+    return disp->flushing_last;
+}
+
+bool lv_display_is_double_buffered(lv_display_t * disp)
+{
+    return disp->buf_2 != NULL;
+}
+
+/*---------------------
+  * SCREENS
+  *--------------------*/
+
+lv_obj_t * lv_display_get_screen_active(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered to get its active screen");
+        return NULL;
+    }
+
+    return disp->act_scr;
+}
+
+lv_obj_t * lv_display_get_screen_loading(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered to get the current screen being loaded");
+        return NULL;
+    }
+
+    return disp->scr_to_load;
+}
+
+lv_obj_t * lv_display_get_screen_prev(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered to get its previous screen");
+        return NULL;
+    }
+
+    return disp->prev_scr;
+}
+
+lv_obj_t * lv_display_get_layer_top(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("lv_layer_top: no display registered to get its top layer");
+        return NULL;
+    }
+
+    return disp->top_layer;
+}
+
+lv_obj_t * lv_display_get_layer_sys(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("lv_layer_sys: no display registered to get its sys. layer");
+        return NULL;
+    }
+
+    return disp->sys_layer;
+}
+
+lv_obj_t * lv_display_get_layer_bottom(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("lv_layer_bottom: no display registered to get its bottom layer");
+        return NULL;
+    }
+
+    return disp->bottom_layer;
+}
+
+#if LV_USE_OBJ_NAME
+
+lv_obj_t * lv_display_get_screen_by_name(const lv_display_t * disp, const char * screen_name)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered to get a screen by name");
+        return NULL;
+    }
+
+    uint32_t i;
+    for(i = 0; i < disp->screen_cnt; i++) {
+        const char * n = lv_obj_get_name(disp->screens[i]);
+        if(n && lv_streq(screen_name, n)) return disp->screens[i];
+    }
+
+    return NULL;
+
+}
+
+#endif /*LV_USE_OBJ_NAME*/
+
+void lv_screen_load(struct _lv_obj_t * scr)
+{
+    lv_screen_load_anim(scr, LV_SCREEN_LOAD_ANIM_NONE, 0, 0, false);
+}
+
+void lv_screen_load_anim(lv_obj_t * new_scr, lv_screen_load_anim_t anim_type, uint32_t time, uint32_t delay,
+                         bool auto_del)
+{
+    lv_display_t * d = lv_obj_get_display(new_scr);
+    lv_obj_t * act_scr = d->act_scr;
+
+    if(act_scr == new_scr || d->scr_to_load == new_scr) {
+        return;
+    }
+
+    /*If another screen load animation is in progress
+     *make target screen loaded immediately. */
+    if(d->scr_to_load && act_scr != d->scr_to_load) {
+        lv_anim_delete(d->scr_to_load, NULL);
+        lv_obj_set_pos(d->scr_to_load, 0, 0);
+        lv_obj_remove_local_style_prop(d->scr_to_load, LV_STYLE_OPA, 0);
+
+        d->prev_scr = d->act_scr;
+        act_scr = d->scr_to_load; /*Active screen changed.*/
+
+        scr_load_internal(d->scr_to_load);
+    }
+
+    d->scr_to_load = new_scr;
+
+    if(d->prev_scr && d->del_prev) lv_obj_delete(d->prev_scr);
+    d->prev_scr = NULL;
+
+    d->draw_prev_over_act = is_out_anim(anim_type);
+    d->del_prev = auto_del;
+
+    /*Be sure there is no other animation on the screens*/
+    lv_anim_delete(new_scr, NULL);
+    if(act_scr) lv_anim_delete(act_scr, NULL);
+
+    /*Be sure both screens are in a normal position*/
+    lv_obj_set_pos(new_scr, 0, 0);
+    if(act_scr) lv_obj_set_pos(act_scr, 0, 0);
+    lv_obj_remove_local_style_prop(new_scr, LV_STYLE_OPA, 0);
+    if(act_scr) lv_obj_remove_local_style_prop(act_scr, LV_STYLE_OPA, 0);
+
+    /*Shortcut for immediate load*/
+    if(time == 0 && delay == 0) {
+        scr_load_internal(new_scr);
+        if(auto_del && act_scr) lv_obj_delete(act_scr);
+        return;
+    }
+
+    lv_anim_t a_new;
+    lv_anim_init(&a_new);
+    lv_anim_set_var(&a_new, new_scr);
+    lv_anim_set_start_cb(&a_new, scr_load_anim_start);
+    lv_anim_set_completed_cb(&a_new, scr_anim_completed);
+    lv_anim_set_duration(&a_new, time);
+    lv_anim_set_delay(&a_new, delay);
+
+    lv_anim_t a_old;
+    lv_anim_init(&a_old);
+    lv_anim_set_var(&a_old, act_scr);
+    lv_anim_set_duration(&a_old, time);
+    lv_anim_set_delay(&a_old, delay);
+
+    switch(anim_type) {
+        case LV_SCREEN_LOAD_ANIM_NONE:
+            /*Create a dummy animation to apply the delay*/
+            lv_anim_set_exec_cb(&a_new, set_x_anim);
+            lv_anim_set_values(&a_new, 0, 0);
+            break;
+        case LV_SCREEN_LOAD_ANIM_OVER_LEFT:
+            lv_anim_set_exec_cb(&a_new, set_x_anim);
+            lv_anim_set_values(&a_new, lv_display_get_horizontal_resolution(d), 0);
+            break;
+        case LV_SCREEN_LOAD_ANIM_OVER_RIGHT:
+            lv_anim_set_exec_cb(&a_new, set_x_anim);
+            lv_anim_set_values(&a_new, -lv_display_get_horizontal_resolution(d), 0);
+            break;
+        case LV_SCREEN_LOAD_ANIM_OVER_TOP:
+            lv_anim_set_exec_cb(&a_new, set_y_anim);
+            lv_anim_set_values(&a_new, lv_display_get_vertical_resolution(d), 0);
+            break;
+        case LV_SCREEN_LOAD_ANIM_OVER_BOTTOM:
+            lv_anim_set_exec_cb(&a_new, set_y_anim);
+            lv_anim_set_values(&a_new, -lv_display_get_vertical_resolution(d), 0);
+            break;
+        case LV_SCREEN_LOAD_ANIM_MOVE_LEFT:
+            lv_anim_set_exec_cb(&a_new, set_x_anim);
+            lv_anim_set_values(&a_new, lv_display_get_horizontal_resolution(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, set_x_anim);
+            lv_anim_set_values(&a_old, 0, -lv_display_get_horizontal_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_MOVE_RIGHT:
+            lv_anim_set_exec_cb(&a_new, set_x_anim);
+            lv_anim_set_values(&a_new, -lv_display_get_horizontal_resolution(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, set_x_anim);
+            lv_anim_set_values(&a_old, 0, lv_display_get_horizontal_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_MOVE_TOP:
+            lv_anim_set_exec_cb(&a_new, set_y_anim);
+            lv_anim_set_values(&a_new, lv_display_get_vertical_resolution(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, set_y_anim);
+            lv_anim_set_values(&a_old, 0, -lv_display_get_vertical_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_MOVE_BOTTOM:
+            lv_anim_set_exec_cb(&a_new, set_y_anim);
+            lv_anim_set_values(&a_new, -lv_display_get_vertical_resolution(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, set_y_anim);
+            lv_anim_set_values(&a_old, 0, lv_display_get_vertical_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_FADE_IN:
+            lv_anim_set_exec_cb(&a_new, opa_scale_anim);
+            lv_anim_set_values(&a_new, LV_OPA_TRANSP, LV_OPA_COVER);
+            break;
+        case LV_SCREEN_LOAD_ANIM_FADE_OUT:
+            lv_anim_set_exec_cb(&a_old, opa_scale_anim);
+            lv_anim_set_values(&a_old, LV_OPA_COVER, LV_OPA_TRANSP);
+            break;
+        case LV_SCREEN_LOAD_ANIM_OUT_LEFT:
+            lv_anim_set_exec_cb(&a_old, set_x_anim);
+            lv_anim_set_values(&a_old, 0, -lv_display_get_horizontal_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_OUT_RIGHT:
+            lv_anim_set_exec_cb(&a_old, set_x_anim);
+            lv_anim_set_values(&a_old, 0, lv_display_get_horizontal_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_OUT_TOP:
+            lv_anim_set_exec_cb(&a_old, set_y_anim);
+            lv_anim_set_values(&a_old, 0, -lv_display_get_vertical_resolution(d));
+            break;
+        case LV_SCREEN_LOAD_ANIM_OUT_BOTTOM:
+            lv_anim_set_exec_cb(&a_old, set_y_anim);
+            lv_anim_set_values(&a_old, 0, lv_display_get_vertical_resolution(d));
+            break;
+    }
+
+    if(act_scr) lv_obj_send_event(act_scr, LV_EVENT_SCREEN_UNLOAD_START, NULL);
+
+    lv_anim_start(&a_new);
+    if(act_scr) lv_anim_start(&a_old);
+}
+
+/*---------------------
+ * OTHERS
+ *--------------------*/
+
+void lv_display_add_event_cb(lv_display_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
+{
+    LV_ASSERT_NULL(disp);
+
+    lv_event_add(&disp->event_list, event_cb, filter, user_data);
+}
+
+uint32_t lv_display_get_event_count(lv_display_t * disp)
+{
+    LV_ASSERT_NULL(disp);
+    return lv_event_get_count(&disp->event_list);
+}
+
+lv_event_dsc_t * lv_display_get_event_dsc(lv_display_t * disp, uint32_t index)
+{
+    LV_ASSERT_NULL(disp);
+    return lv_event_get_dsc(&disp->event_list, index);
+
+}
+
+bool lv_display_delete_event(lv_display_t * disp, uint32_t index)
+{
+    LV_ASSERT_NULL(disp);
+
+    return lv_event_remove(&disp->event_list, index);
+}
+
+uint32_t lv_display_remove_event_cb_with_user_data(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data)
+{
+    LV_ASSERT_NULL(disp);
+
+    uint32_t event_cnt = lv_display_get_event_count(disp);
+    uint32_t removed_count = 0;
+    int32_t i;
+
+    for(i = event_cnt - 1; i >= 0; i--) {
+        lv_event_dsc_t * dsc = lv_display_get_event_dsc(disp, i);
+        if(dsc && dsc->cb == event_cb && dsc->user_data == user_data) {
+            lv_display_delete_event(disp, i);
+            removed_count ++;
+        }
+    }
+
+    return removed_count;
+}
+
+lv_result_t lv_display_send_event(lv_display_t * disp, lv_event_code_t code, void * param)
+{
+    return lv_event_push_and_send(&disp->event_list, code, disp, param);
+}
+
+lv_area_t * lv_event_get_invalidated_area(lv_event_t * e)
+{
+    if(e->code == LV_EVENT_INVALIDATE_AREA) {
+        return lv_event_get_param(e);
+    }
+    else {
+        LV_LOG_WARN("Not interpreted with this event code");
+        return NULL;
+    }
+}
+
+void lv_display_set_rotation(lv_display_t * disp, lv_display_rotation_t rotation)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    disp->rotation = rotation;
+    update_resolution(disp);
+}
+
+lv_display_rotation_t lv_display_get_rotation(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return LV_DISPLAY_ROTATION_0;
+    return disp->rotation;
+}
+
+void lv_display_set_matrix_rotation(lv_display_t * disp, bool enable)
+{
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return;
+
+    if(!(disp->render_mode == LV_DISPLAY_RENDER_MODE_DIRECT || disp->render_mode == LV_DISPLAY_RENDER_MODE_FULL)) {
+        LV_LOG_WARN("Unsupported rendering mode: %d", disp->render_mode);
+        return;
+    }
+
+    disp->matrix_rotation = enable;
+#else
+    (void)disp;
+    (void)enable;
+    LV_LOG_WARN("LV_DRAW_TRANSFORM_USE_MATRIX was not enabled");
+#endif
+}
+
+bool lv_display_get_matrix_rotation(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    if(disp == NULL) return false;
+    return disp->matrix_rotation;
+}
+
+void lv_display_set_theme(lv_display_t * disp, lv_theme_t * th)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return;
+    }
+
+    disp->theme = th;
+
+    if(disp->screen_cnt == 4 &&
+       lv_obj_get_child_count(disp->screens[0]) == 0 &&
+       lv_obj_get_child_count(disp->screens[1]) == 0 &&
+       lv_obj_get_child_count(disp->screens[2]) == 0) {
+        lv_theme_apply(disp->screens[0]);
+    }
+}
+
+lv_theme_t * lv_display_get_theme(lv_display_t * disp)
+{
+    if(disp == NULL) disp = lv_display_get_default();
+    return disp->theme;
+}
+
+uint32_t lv_display_get_inactive_time(const lv_display_t * disp)
+{
+    if(disp) return lv_tick_elaps(disp->last_activity_time);
+
+    lv_display_t * d;
+    uint32_t t = UINT32_MAX;
+    d          = lv_display_get_next(NULL);
+    while(d) {
+        uint32_t elaps = lv_tick_elaps(d->last_activity_time);
+        t = LV_MIN(t, elaps);
+        d = lv_display_get_next(d);
+    }
+
+    return t;
+}
+
+void lv_display_trigger_activity(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("lv_display_trigger_activity: no display registered");
+        return;
+    }
+
+    disp->last_activity_time = lv_tick_get();
+}
+
+void lv_display_enable_invalidation(lv_display_t * disp, bool en)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return;
+    }
+
+    disp->inv_en_cnt += en ? 1 : -1;
+}
+
+bool lv_display_is_invalidation_enabled(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return false;
+    }
+
+    return (disp->inv_en_cnt > 0);
+}
+
+lv_timer_t * lv_display_get_refr_timer(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return NULL;
+
+    return disp->refr_timer;
+}
+
+void lv_display_delete_refr_timer(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp || !disp->refr_timer) return;
+
+    lv_timer_delete(disp->refr_timer);
+    disp->refr_timer = NULL;
+}
+
+lv_result_t lv_display_send_vsync_event(lv_display_t * disp, void * param)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return LV_RESULT_INVALID;
+
+    if(disp->vsync_count > 0)
+        return lv_display_send_event(disp, LV_EVENT_VSYNC, param);
+
+    return LV_RESULT_INVALID;
+}
+
+bool lv_display_register_vsync_event(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return false;
+
+    lv_display_add_event_cb(disp, event_cb, LV_EVENT_VSYNC, user_data);
+
+    /*only send once*/
+    if(disp->vsync_count == 0)
+        lv_display_send_event(disp, LV_EVENT_VSYNC_REQUEST, disp);
+
+    disp->vsync_count++;
+    return true;
+}
+
+bool lv_display_unregister_vsync_event(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return false;
+
+    uint32_t removed_count = lv_display_remove_event_cb_with_user_data(disp, event_cb, user_data);
+    if(removed_count == 0)
+        return false;
+
+    disp->vsync_count -= removed_count;
+    /*only send once*/
+    if(disp->vsync_count == 0)
+        lv_display_send_event(disp, LV_EVENT_VSYNC_REQUEST, NULL);
+
+    return true;
+}
+
+void lv_display_set_user_data(lv_display_t * disp, void * user_data)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return;
+    disp->user_data = user_data;
+}
+
+void lv_display_set_driver_data(lv_display_t * disp, void * driver_data)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return;
+
+    disp->driver_data = driver_data;
+}
+
+void * lv_display_get_user_data(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return NULL;
+    return disp->user_data;
+}
+
+void * lv_display_get_driver_data(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return NULL;
+
+    return disp->driver_data;
+}
+
+lv_draw_buf_t * lv_display_get_buf_active(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return NULL;
+    return disp->buf_act;
+}
+
+void lv_display_rotate_area(lv_display_t * disp, lv_area_t * area)
+{
+    lv_display_rotation_t rotation = lv_display_get_rotation(disp);
+
+    if(rotation == LV_DISPLAY_ROTATION_0) return;
+
+    int32_t w = lv_area_get_width(area);
+    int32_t h = lv_area_get_height(area);
+
+    switch(rotation) {
+        case LV_DISPLAY_ROTATION_90:
+            area->y2 = disp->ver_res - area->x1 - 1;
+            area->x1 = area->y1;
+            area->x2 = area->x1 + h - 1;
+            area->y1 = area->y2 - w + 1;
+            break;
+        case LV_DISPLAY_ROTATION_180:
+            area->y2 = disp->ver_res - area->y1 - 1;
+            area->y1 = area->y2 - h + 1;
+            area->x2 = disp->hor_res - area->x1 - 1;
+            area->x1 = area->x2 - w + 1;
+            break;
+        case LV_DISPLAY_ROTATION_270:
+            area->x1 = disp->hor_res - area->y2 - 1;
+            area->y2 = area->x2;
+            area->x2 = area->x1 + h - 1;
+            area->y1 = area->y2 - w + 1;
+            break;
+        default:
+            break;
+    }
+}
+
+uint32_t lv_display_get_draw_buf_size(lv_display_t * disp)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return 0;
+
+    if(disp->buf_1) {
+        return disp->buf_1->data_size;
+    }
+    return 0;
+}
+
+uint32_t lv_display_get_invalidated_draw_buf_size(lv_display_t * disp, uint32_t width, uint32_t height)
+{
+    if(!disp) disp = lv_display_get_default();
+    if(!disp) return 0;
+
+    if(disp->render_mode == LV_DISPLAY_RENDER_MODE_FULL) {
+        width = lv_display_get_horizontal_resolution(disp);
+        height = lv_display_get_vertical_resolution(disp);
+    }
+
+    lv_color_format_t cf = lv_display_get_color_format(disp);
+    uint32_t stride = lv_draw_buf_width_to_stride(width, cf);
+    uint32_t buf_size = stride * height;
+
+    LV_ASSERT(disp->buf_1 && disp->buf_1->data_size >= buf_size);
+    if(disp->buf_2) LV_ASSERT(disp->buf_2->data_size >= buf_size);
+    if(disp->buf_3) LV_ASSERT(disp->buf_3->data_size >= buf_size);
+
+    return buf_size;
+}
+
+lv_obj_t * lv_screen_active(void)
+{
+    return lv_display_get_screen_active(lv_display_get_default());
+}
+
+lv_obj_t * lv_layer_top(void)
+{
+    return lv_display_get_layer_top(lv_display_get_default());
+}
+
+lv_obj_t * lv_layer_sys(void)
+{
+    return lv_display_get_layer_sys(lv_display_get_default());
+}
+
+lv_obj_t * lv_layer_bottom(void)
+{
+    return lv_display_get_layer_bottom(lv_display_get_default());
+}
+
+int32_t lv_dpx(int32_t n)
+{
+    return LV_DPX(n);
+}
+
+int32_t lv_display_dpx(const lv_display_t * disp, int32_t n)
+{
+    return LV_DPX_CALC(lv_display_get_dpi(disp), n);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void update_resolution(lv_display_t * disp)
+{
+    int32_t hor_res = lv_display_get_horizontal_resolution(disp);
+    int32_t ver_res = lv_display_get_vertical_resolution(disp);
+
+    lv_area_t prev_coords;
+    lv_obj_get_coords(disp->sys_layer, &prev_coords);
+    uint32_t i;
+    for(i = 0; i < disp->screen_cnt; i++) {
+        lv_area_set_width(&disp->screens[i]->coords, hor_res);
+        lv_area_set_height(&disp->screens[i]->coords, ver_res);
+        lv_obj_send_event(disp->screens[i], LV_EVENT_SIZE_CHANGED, &prev_coords);
+    }
+
+    lv_area_set_width(&disp->top_layer->coords, hor_res);
+    lv_area_set_height(&disp->top_layer->coords, ver_res);
+    lv_obj_send_event(disp->top_layer, LV_EVENT_SIZE_CHANGED, &prev_coords);
+
+    lv_area_set_width(&disp->sys_layer->coords, hor_res);
+    lv_area_set_height(&disp->sys_layer->coords, ver_res);
+    lv_obj_send_event(disp->sys_layer, LV_EVENT_SIZE_CHANGED, &prev_coords);
+
+    lv_area_set_width(&disp->bottom_layer->coords, hor_res);
+    lv_area_set_height(&disp->bottom_layer->coords, ver_res);
+    lv_obj_send_event(disp->bottom_layer, LV_EVENT_SIZE_CHANGED, &prev_coords);
+
+    lv_memzero(disp->inv_areas, sizeof(disp->inv_areas));
+    lv_memzero(disp->inv_area_joined, sizeof(disp->inv_area_joined));
+    disp->inv_p = 0;
+    lv_obj_invalidate(disp->sys_layer);
+
+    lv_obj_tree_walk(NULL, invalidate_layout_cb, NULL);
+
+    lv_display_send_event(disp, LV_EVENT_RESOLUTION_CHANGED, NULL);
+}
+
+static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_data)
+{
+    LV_UNUSED(user_data);
+    lv_obj_mark_layout_as_dirty(obj);
+    return LV_OBJ_TREE_WALK_NEXT;
+}
+
+static void scr_load_internal(lv_obj_t * scr)
+{
+    /*scr must not be NULL, but d->act_scr might be*/
+    LV_ASSERT_NULL(scr);
+    if(scr == NULL) return;
+
+    lv_display_t * d = lv_obj_get_display(scr);
+    if(!d) return;  /*Shouldn't happen, just to be sure*/
+
+    lv_obj_t * old_scr = d->act_scr;
+
+    if(old_scr) lv_obj_send_event(old_scr, LV_EVENT_SCREEN_UNLOAD_START, NULL);
+    lv_obj_send_event(scr, LV_EVENT_SCREEN_LOAD_START, NULL);
+
+    d->act_scr = scr;
+    d->scr_to_load = NULL;
+
+    lv_obj_send_event(scr, LV_EVENT_SCREEN_LOADED, NULL);
+    if(old_scr) lv_obj_send_event(old_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
+
+    lv_obj_invalidate(scr);
+}
+
+static void scr_load_anim_start(lv_anim_t * a)
+{
+    lv_display_t * d = lv_obj_get_display(a->var);
+
+    d->prev_scr = d->act_scr;
+    d->act_scr = a->var;
+
+    lv_obj_send_event(d->act_scr, LV_EVENT_SCREEN_LOAD_START, NULL);
+}
+
+static void opa_scale_anim(void * obj, int32_t v)
+{
+    lv_obj_set_style_opa(obj, v, 0);
+}
+
+static void set_x_anim(void * obj, int32_t v)
+{
+    lv_obj_set_x(obj, v);
+}
+
+static void set_y_anim(void * obj, int32_t v)
+{
+    lv_obj_set_y(obj, v);
+}
+
+static void scr_anim_completed(lv_anim_t * a)
+{
+    lv_display_t * d = lv_obj_get_display(a->var);
+
+    lv_obj_send_event(d->act_scr, LV_EVENT_SCREEN_LOADED, NULL);
+    lv_obj_send_event(d->prev_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
+
+    if(d->prev_scr && d->del_prev) lv_obj_delete(d->prev_scr);
+    d->prev_scr = NULL;
+    d->draw_prev_over_act = false;
+    d->scr_to_load = NULL;
+    lv_obj_remove_local_style_prop(a->var, LV_STYLE_OPA, 0);
+    lv_obj_invalidate(d->act_scr);
+}
+
+static bool is_out_anim(lv_screen_load_anim_t anim_type)
+{
+    return anim_type == LV_SCREEN_LOAD_ANIM_FADE_OUT  ||
+           anim_type == LV_SCREEN_LOAD_ANIM_OUT_LEFT  ||
+           anim_type == LV_SCREEN_LOAD_ANIM_OUT_RIGHT ||
+           anim_type == LV_SCREEN_LOAD_ANIM_OUT_TOP   ||
+           anim_type == LV_SCREEN_LOAD_ANIM_OUT_BOTTOM;
+}
+
+static void disp_event_cb(lv_event_t * e)
+{
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_display_t * disp = lv_event_get_target(e);
+    switch(code) {
+        case LV_EVENT_REFR_REQUEST:
+            if(disp->refr_timer) lv_timer_resume(disp->refr_timer);
+            break;
+
+        default:
+            break;
+    }
+}

components/easylvgl/lvgl9/src/display/lv_display.h

@@ -0,0 +1,732 @@
+/**
+ * @file lv_display.h
+ *
+ */
+
+#ifndef LV_DISPLAY_H
+#define LV_DISPLAY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_timer.h"
+#include "../misc/lv_event.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#ifndef LV_ATTRIBUTE_FLUSH_READY
+#define LV_ATTRIBUTE_FLUSH_READY
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_DISPLAY_ROTATION_0 = 0,
+    LV_DISPLAY_ROTATION_90,
+    LV_DISPLAY_ROTATION_180,
+    LV_DISPLAY_ROTATION_270
+} lv_display_rotation_t;
+
+typedef enum {
+    /**
+     * Use the buffer(s) to render the screen is smaller parts.
+     * This way the buffers can be smaller then the display to save RAM. At least 1/10 screen size buffer(s) are recommended.
+     */
+    LV_DISPLAY_RENDER_MODE_PARTIAL,
+
+    /**
+     * The buffer(s) has to be screen sized and LVGL will render into the correct location of the buffer.
+     * This way the buffer always contain the whole image. Only the changed ares will be updated.
+     * With 2 buffers the buffers' content are kept in sync automatically and in flush_cb only address change is required.
+     */
+    LV_DISPLAY_RENDER_MODE_DIRECT,
+
+    /**
+     * Always redraw the whole screen even if only one pixel has been changed.
+     * With 2 buffers in flush_cb only an address change is required.
+     */
+    LV_DISPLAY_RENDER_MODE_FULL,
+} lv_display_render_mode_t;
+
+typedef enum {
+    LV_SCREEN_LOAD_ANIM_NONE,
+    LV_SCREEN_LOAD_ANIM_OVER_LEFT,
+    LV_SCREEN_LOAD_ANIM_OVER_RIGHT,
+    LV_SCREEN_LOAD_ANIM_OVER_TOP,
+    LV_SCREEN_LOAD_ANIM_OVER_BOTTOM,
+    LV_SCREEN_LOAD_ANIM_MOVE_LEFT,
+    LV_SCREEN_LOAD_ANIM_MOVE_RIGHT,
+    LV_SCREEN_LOAD_ANIM_MOVE_TOP,
+    LV_SCREEN_LOAD_ANIM_MOVE_BOTTOM,
+    LV_SCREEN_LOAD_ANIM_FADE_IN,
+    LV_SCREEN_LOAD_ANIM_FADE_ON = LV_SCREEN_LOAD_ANIM_FADE_IN, /*For backward compatibility*/
+    LV_SCREEN_LOAD_ANIM_FADE_OUT,
+    LV_SCREEN_LOAD_ANIM_OUT_LEFT,
+    LV_SCREEN_LOAD_ANIM_OUT_RIGHT,
+    LV_SCREEN_LOAD_ANIM_OUT_TOP,
+    LV_SCREEN_LOAD_ANIM_OUT_BOTTOM,
+} lv_screen_load_anim_t;
+
+typedef void (*lv_display_flush_cb_t)(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map);
+typedef void (*lv_display_flush_wait_cb_t)(lv_display_t * disp);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a new display with the given resolution
+ * @param hor_res   horizontal resolution in pixels
+ * @param ver_res   vertical resolution in pixels
+ * @return          pointer to a display object or `NULL` on error
+ */
+lv_display_t * lv_display_create(int32_t hor_res, int32_t ver_res);
+
+/**
+ * Remove a display
+ * @param disp      pointer to display
+ */
+void lv_display_delete(lv_display_t * disp);
+
+/**
+ * Set a default display. The new screens will be created on it by default.
+ * @param disp      pointer to a display
+ */
+void lv_display_set_default(lv_display_t * disp);
+
+/**
+ * Get the default display
+ * @return          pointer to the default display
+ */
+lv_display_t * lv_display_get_default(void);
+
+/**
+ * Get the next display.
+ * @param disp      pointer to the current display. NULL to initialize.
+ * @return          the next display or NULL if no more. Gives the first display when the parameter is NULL.
+ */
+lv_display_t * lv_display_get_next(lv_display_t * disp);
+
+/*---------------------
+ * RESOLUTION
+ *--------------------*/
+
+/**
+ * Sets the resolution of a display. `LV_EVENT_RESOLUTION_CHANGED` event will be sent.
+ * Here the native resolution of the device should be set. If the display will be rotated later with
+ * `lv_display_set_rotation` LVGL will swap the hor. and ver. resolution automatically.
+ * @param disp      pointer to a display
+ * @param hor_res   the new horizontal resolution
+ * @param ver_res   the new vertical resolution
+ */
+void lv_display_set_resolution(lv_display_t * disp, int32_t hor_res, int32_t ver_res);
+
+/**
+ * It's not mandatory to use the whole display for LVGL, however in some cases physical resolution is important.
+ * For example the touchpad still sees whole resolution and the values needs to be converted
+ * to the active LVGL display area.
+ * @param disp      pointer to a display
+ * @param hor_res   the new physical horizontal resolution, or -1 to assume it's the same as the normal hor. res.
+ * @param ver_res   the new physical vertical resolution, or -1 to assume it's the same as the normal hor. res.
+ */
+void lv_display_set_physical_resolution(lv_display_t * disp, int32_t hor_res, int32_t ver_res);
+
+/**
+ * If physical resolution is not the same as the normal resolution
+ * the offset of the active display area can be set here.
+ * @param disp      pointer to a display
+ * @param x         X offset
+ * @param y         Y offset
+ */
+void lv_display_set_offset(lv_display_t * disp, int32_t x, int32_t y);
+
+/**
+ * Set the rotation of this display. LVGL will swap the horizontal and vertical resolutions internally.
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @param rotation  `LV_DISPLAY_ROTATION_0/90/180/270`
+ */
+void lv_display_set_rotation(lv_display_t * disp, lv_display_rotation_t rotation);
+
+/**
+ * Use matrix rotation for the display. This function is depended on `LV_DRAW_TRANSFORM_USE_MATRIX`
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @param enable    true: enable matrix rotation, false: disable
+ */
+void lv_display_set_matrix_rotation(lv_display_t * disp, bool enable);
+
+/**
+ * Set the DPI (dot per inch) of the display.
+ * dpi = sqrt(hor_res^2 + ver_res^2) / diagonal"
+ * @param disp      pointer to a display
+ * @param dpi       the new DPI
+ */
+void lv_display_set_dpi(lv_display_t * disp, int32_t dpi);
+
+/**
+ * Get the horizontal resolution of a display.
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the horizontal resolution of the display.
+ */
+int32_t lv_display_get_horizontal_resolution(const lv_display_t * disp);
+
+/**
+ * Get the vertical resolution of a display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the vertical resolution of the display
+ */
+int32_t lv_display_get_vertical_resolution(const lv_display_t * disp);
+
+/**
+ * Get the original horizontal resolution of a display without considering rotation
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the horizontal resolution of the display.
+ */
+int32_t lv_display_get_original_horizontal_resolution(const lv_display_t * disp);
+
+/**
+ * Get the original vertical resolution of a display without considering rotation
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the vertical resolution of the display
+ */
+int32_t lv_display_get_original_vertical_resolution(const lv_display_t * disp);
+
+/**
+ * Get the physical horizontal resolution of a display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return the      physical horizontal resolution of the display
+ */
+int32_t lv_display_get_physical_horizontal_resolution(const lv_display_t * disp);
+
+/**
+ * Get the physical vertical resolution of a display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the physical vertical resolution of the display
+ */
+int32_t lv_display_get_physical_vertical_resolution(const lv_display_t * disp);
+
+/**
+ * Get the horizontal offset from the full / physical display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the horizontal offset from the physical display
+ */
+int32_t lv_display_get_offset_x(const lv_display_t * disp);
+
+/**
+ * Get the vertical offset from the full / physical display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the horizontal offset from the physical display
+ */
+int32_t lv_display_get_offset_y(const lv_display_t * disp);
+
+/**
+ * Get the current rotation of this display.
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          the current rotation
+ */
+lv_display_rotation_t lv_display_get_rotation(lv_display_t * disp);
+
+/**
+ * Get if matrix rotation is enabled for a display or not
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          true: matrix rotation is enabled; false: disabled
+ */
+bool lv_display_get_matrix_rotation(lv_display_t * disp);
+
+/**
+ * Get the DPI of the display
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          dpi of the display
+ */
+int32_t lv_display_get_dpi(const lv_display_t * disp);
+
+/*---------------------
+ * BUFFERING
+ *--------------------*/
+
+/**
+ * Set the buffers for a display, similarly to `lv_display_set_draw_buffers`, but accept the raw buffer pointers.
+ * For DIRECT/FULL rending modes, the buffer size must be at least
+ * `hor_res * ver_res * lv_color_format_get_size(lv_display_get_color_format(disp))`
+ * @param disp              pointer to a display
+ * @param buf1              first buffer
+ * @param buf2              second buffer (can be `NULL`)
+ * @param buf_size          buffer size in byte
+ * @param render_mode       LV_DISPLAY_RENDER_MODE_PARTIAL/DIRECT/FULL
+ */
+void lv_display_set_buffers(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size,
+                            lv_display_render_mode_t render_mode);
+
+/**
+ * Set the frame buffers for a display, similarly to `lv_display_set_buffers`, but allow
+ * for a custom stride as required by a display controller.
+ * This allows the frame buffers to have a stride alignment different from the rest of
+ * the buffers`
+ * @param disp              pointer to a display
+ * @param buf1              first buffer
+ * @param buf2              second buffer (can be `NULL`)
+ * @param buf_size          buffer size in byte
+ * @param stride            buffer stride in bytes
+ * @param render_mode       LV_DISPLAY_RENDER_MODE_PARTIAL/DIRECT/FULL
+ */
+void lv_display_set_buffers_with_stride(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size,
+                                        uint32_t stride, lv_display_render_mode_t render_mode);
+
+/**
+ * Set the buffers for a display, accept a draw buffer pointer.
+ * Normally use `lv_display_set_buffers` is enough for most cases.
+ * Use this function when an existing lv_draw_buf_t is available.
+ * @param disp              pointer to a display
+ * @param buf1              first buffer
+ * @param buf2              second buffer (can be `NULL`)
+ */
+void lv_display_set_draw_buffers(lv_display_t * disp, lv_draw_buf_t * buf1, lv_draw_buf_t * buf2);
+
+/**
+ * Set the third draw buffer for a display.
+ * @param disp              pointer to a display
+ * @param buf3              third buffer
+ */
+void lv_display_set_3rd_draw_buffer(lv_display_t * disp, lv_draw_buf_t * buf3);
+
+/**
+ * Set display render mode
+ * @param disp              pointer to a display
+ * @param render_mode       LV_DISPLAY_RENDER_MODE_PARTIAL/DIRECT/FULL
+ */
+void lv_display_set_render_mode(lv_display_t * disp, lv_display_render_mode_t render_mode);
+
+/**
+ * Set the flush callback which will be called to copy the rendered image to the display.
+ * @param disp      pointer to a display
+ * @param flush_cb  the flush callback (`px_map` contains the rendered image as raw pixel map and it should be copied to `area` on the display)
+ */
+void lv_display_set_flush_cb(lv_display_t * disp, lv_display_flush_cb_t flush_cb);
+
+/**
+ * Set a callback to be used while LVGL is waiting flushing to be finished.
+ * It can do any complex logic to wait, including semaphores, mutexes, polling flags, etc.
+ * If not set the `disp->flushing` flag is used which can be cleared with `lv_display_flush_ready()`
+ * @param disp      pointer to a display
+ * @param wait_cb   a callback to call while LVGL is waiting for flush ready.
+ *                  If NULL `lv_display_flush_ready()` can be used to signal that flushing is ready.
+ */
+void lv_display_set_flush_wait_cb(lv_display_t * disp, lv_display_flush_wait_cb_t wait_cb);
+
+/**
+ * Set the color format of the display.
+ * @param disp              pointer to a display
+ * @param color_format      Possible values are
+ *                          - LV_COLOR_FORMAT_RGB565
+ *                          - LV_COLOR_FORMAT_RGB888
+ *                          - LV_COLOR_FORMAT_XRGB888
+ *                          - LV_COLOR_FORMAT_ARGB888
+ *@note To change the endianness of the rendered image in case of RGB565 format
+ *      (i.e. swap the 2 bytes) call `lv_draw_sw_rgb565_swap` in the flush_cb
+ */
+void lv_display_set_color_format(lv_display_t * disp, lv_color_format_t color_format);
+
+/**
+ * Get the color format of the display
+ * @param disp              pointer to a display
+ * @return                  the color format
+ */
+lv_color_format_t lv_display_get_color_format(lv_display_t * disp);
+
+/**
+ * Set the number of tiles for parallel rendering.
+ * @param disp              pointer to a display
+ * @param tile_cnt          number of tiles (1 =< tile_cnt < 256)
+ */
+void lv_display_set_tile_cnt(lv_display_t * disp, uint32_t tile_cnt);
+
+/**
+ * Get the number of tiles used for parallel rendering
+ * @param disp              pointer to a display
+ * @return                  number of tiles
+ */
+uint32_t lv_display_get_tile_cnt(lv_display_t * disp);
+
+/**
+ * Disabling anti-aliasing is not supported since v9. This function will be removed.
+ * Enable anti-aliasing for the render engine
+ * @param disp      pointer to a display
+ * @param en        true/false
+ */
+void lv_display_set_antialiasing(lv_display_t * disp, bool en);
+
+/**
+ * Get if anti-aliasing is enabled for a display or not
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return          true/false
+ */
+bool lv_display_get_antialiasing(lv_display_t * disp);
+
+/**
+ * Call from the display driver when the flushing is finished
+ * @param disp      pointer to display whose `flush_cb` was called
+ */
+LV_ATTRIBUTE_FLUSH_READY void lv_display_flush_ready(lv_display_t * disp);
+
+/**
+ * Tell if it's the last area of the refreshing process.
+ * Can be called from `flush_cb` to execute some special display refreshing if needed when all areas area flushed.
+ * @param disp      pointer to display
+ * @return          true: it's the last area to flush;
+ *                  false: there are other areas too which will be refreshed soon
+ */
+LV_ATTRIBUTE_FLUSH_READY bool lv_display_flush_is_last(lv_display_t * disp);
+
+bool lv_display_is_double_buffered(lv_display_t * disp);
+
+/*---------------------
+ * SCREENS
+ *--------------------*/
+
+/**
+ * Return a pointer to the active screen on a display
+ * @param disp      pointer to display which active screen should be get.
+ *                  (NULL to use the default screen)
+ * @return          pointer to the active screen object (loaded by 'lv_screen_load()')
+ */
+lv_obj_t * lv_display_get_screen_active(lv_display_t * disp);
+
+/**
+ * Return with a pointer to the previous screen. Only used during screen transitions.
+ * @param disp      pointer to display which previous screen should be get.
+ *                  (NULL to use the default screen)
+ * @return          pointer to the previous screen object or NULL if not used now
+ */
+lv_obj_t * lv_display_get_screen_prev(lv_display_t * disp);
+
+/**
+ * Return the screen that is currently being loaded by the display
+ * @param disp      pointer to a display object (NULL to use the default screen)
+ * @return          pointer to the screen being loaded or NULL if no screen is currently being loaded
+ */
+lv_obj_t * lv_display_get_screen_loading(lv_display_t * disp);
+
+/**
+ * Return the top layer. The top layer is the same on all screens and it is above the normal screen layer.
+ * @param disp      pointer to display which top layer should be get. (NULL to use the default screen)
+ * @return          pointer to the top layer object
+ */
+lv_obj_t * lv_display_get_layer_top(lv_display_t * disp);
+
+/**
+ * Return the sys. layer. The system layer is the same on all screen and it is above the normal screen and the top layer.
+ * @param disp      pointer to display which sys. layer should be retrieved. (NULL to use the default screen)
+ * @return          pointer to the sys layer object
+ */
+lv_obj_t * lv_display_get_layer_sys(lv_display_t * disp);
+
+/**
+ * Return the bottom layer. The bottom layer is the same on all screen and it is under the normal screen layer.
+ * It's visible only if the screen is transparent.
+ * @param disp      pointer to display (NULL to use the default screen)
+ * @return          pointer to the bottom layer object
+ */
+lv_obj_t * lv_display_get_layer_bottom(lv_display_t * disp);
+
+
+#if LV_USE_OBJ_NAME
+
+/**
+ * Get screen by its name on a display. The name should be set by
+ * `lv_obj_set_name()` or `lv_obj_set_name_static()`.
+ * @param disp          pointer to a display or NULL to use default display
+ * @param screen_name   name of the screen to get
+ * @return              pointer to the screen, or NULL if not found.
+ */
+lv_obj_t * lv_display_get_screen_by_name(const lv_display_t * disp, const char * screen_name);
+
+#endif /*LV_USE_OBJ_NAME*/
+
+/**
+ * Load a screen on the default display
+ * @param scr       pointer to a screen
+ */
+void lv_screen_load(struct _lv_obj_t * scr);
+
+/**
+ * Switch screen with animation
+ * @param scr       pointer to the new screen to load
+ * @param anim_type type of the animation from `lv_screen_load_anim_t`, e.g. `LV_SCREEN_LOAD_ANIM_MOVE_LEFT`
+ * @param time      time of the animation
+ * @param delay     delay before the transition
+ * @param auto_del  true: automatically delete the old screen
+ */
+void lv_screen_load_anim(lv_obj_t * scr, lv_screen_load_anim_t anim_type, uint32_t time, uint32_t delay,
+                         bool auto_del);
+
+/**
+ * Get the active screen of the default display
+ * @return          pointer to the active screen
+ */
+lv_obj_t * lv_screen_active(void);
+
+/**
+ * Get the top layer  of the default display
+ * @return          pointer to the top layer
+ */
+lv_obj_t * lv_layer_top(void);
+
+/**
+ * Get the system layer  of the default display
+ * @return          pointer to the sys layer
+ */
+lv_obj_t * lv_layer_sys(void);
+
+/**
+ * Get the bottom layer  of the default display
+ * @return          pointer to the bottom layer
+ */
+lv_obj_t * lv_layer_bottom(void);
+
+/*---------------------
+ * OTHERS
+ *--------------------*/
+
+/**
+ * Add an event handler to the display
+ * @param disp          pointer to a display
+ * @param event_cb      an event callback
+ * @param filter        event code to react or `LV_EVENT_ALL`
+ * @param user_data     optional user_data
+ */
+void lv_display_add_event_cb(lv_display_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data);
+
+/**
+ * Get the number of event attached to a display
+ * @param disp          pointer to a display
+ * @return              number of events
+ */
+uint32_t lv_display_get_event_count(lv_display_t * disp);
+
+/**
+ * Get an event descriptor for an event
+ * @param disp          pointer to a display
+ * @param index         the index of the event
+ * @return              the event descriptor
+ */
+lv_event_dsc_t * lv_display_get_event_dsc(lv_display_t * disp, uint32_t index);
+
+/**
+ * Remove an event
+ * @param disp          pointer to a display
+ * @param index         the index of the event to remove
+ * @return              true: and event was removed; false: no event was removed
+ */
+bool lv_display_delete_event(lv_display_t * disp, uint32_t index);
+
+/**
+ * Remove an event_cb with user_data
+ * @param disp          pointer to a display
+ * @param event_cb      the event_cb of the event to remove
+ * @param user_data     user_data
+ * @return              the count of the event removed
+ */
+uint32_t lv_display_remove_event_cb_with_user_data(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data);
+
+/**
+ * Send an event to a display
+ * @param disp          pointer to a display
+ * @param code          an event code. LV_EVENT_...
+ * @param param         optional param
+ * @return              LV_RESULT_OK: disp wasn't deleted in the event.
+ */
+lv_result_t lv_display_send_event(lv_display_t * disp, lv_event_code_t code, void * param);
+
+/**
+ * Get the area to be invalidated. Can be used in `LV_EVENT_INVALIDATE_AREA`
+ * @param e     pointer to an event
+ * @return      the area to invalidated (can be modified as required)
+ */
+lv_area_t * lv_event_get_invalidated_area(lv_event_t * e);
+
+/**
+ * Set the theme of a display. If there are no user created widgets yet the screens' theme will be updated
+ * @param disp      pointer to a display
+ * @param th        pointer to a theme
+ */
+void lv_display_set_theme(lv_display_t * disp, lv_theme_t * th);
+
+/**
+ * Get the theme of a display
+ * @param disp      pointer to a display
+ * @return          the display's theme (can be NULL)
+ */
+lv_theme_t * lv_display_get_theme(lv_display_t * disp);
+
+/**
+ * Get elapsed time since last user activity on a display (e.g. click)
+ * @param disp      pointer to a display (NULL to get the overall smallest inactivity)
+ * @return          elapsed ticks (milliseconds) since the last activity
+ */
+uint32_t lv_display_get_inactive_time(const lv_display_t * disp);
+
+/**
+ * Manually trigger an activity on a display
+ * @param disp      pointer to a display (NULL to use the default display)
+ */
+void lv_display_trigger_activity(lv_display_t * disp);
+
+/**
+ * Temporarily enable and disable the invalidation of the display.
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @param en        true: enable invalidation; false: invalidation
+ */
+void lv_display_enable_invalidation(lv_display_t * disp, bool en);
+
+/**
+ * Get display invalidation is enabled.
+ * @param disp      pointer to a display (NULL to use the default display)
+ * @return return   true if invalidation is enabled
+ */
+bool lv_display_is_invalidation_enabled(lv_display_t * disp);
+
+/**
+ * Get a pointer to the screen refresher timer to
+ * modify its parameters with `lv_timer_...` functions.
+ * @param disp      pointer to a display
+ * @return          pointer to the display refresher timer. (NULL on error)
+ */
+lv_timer_t * lv_display_get_refr_timer(lv_display_t * disp);
+
+/**
+ * Delete screen refresher timer
+ * @param disp      pointer to a display
+ */
+void lv_display_delete_refr_timer(lv_display_t * disp);
+
+/**
+ * Register vsync event of a display. `LV_EVENT_VSYNC` event will be sent periodically.
+ * Please don't use it in display event listeners, as it may cause memory leaks and illegal access issues.
+ *
+ * @param disp      pointer to a display
+ * @param event_cb      an event callback
+ * @param user_data     optional user_data
+ */
+bool lv_display_register_vsync_event(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data);
+
+/**
+ * Unregister vsync event of a display. `LV_EVENT_VSYNC` event won't be sent periodically.
+ * Please don't use it in display event listeners, as it may cause memory leaks and illegal access issues.
+ * @param disp      pointer to a display
+ * @param event_cb      an event callback
+ * @param user_data     optional user_data
+ */
+bool lv_display_unregister_vsync_event(lv_display_t * disp, lv_event_cb_t event_cb, void * user_data);
+
+/**
+ * Send an vsync event to a display
+ * @param disp          pointer to a display
+ * @param param         optional param
+ * @return              LV_RESULT_OK: disp wasn't deleted in the event.
+ */
+lv_result_t lv_display_send_vsync_event(lv_display_t * disp, void * param);
+
+void lv_display_set_user_data(lv_display_t * disp, void * user_data);
+void lv_display_set_driver_data(lv_display_t * disp, void * driver_data);
+void * lv_display_get_user_data(lv_display_t * disp);
+void * lv_display_get_driver_data(lv_display_t * disp);
+lv_draw_buf_t * lv_display_get_buf_active(lv_display_t * disp);
+
+/**
+ * Rotate an area in-place according to the display's rotation
+ * @param disp      pointer to a display
+ * @param area      pointer to an area to rotate
+ */
+void lv_display_rotate_area(lv_display_t * disp, lv_area_t * area);
+
+/**
+ * Get the size of the draw buffers
+ * @param disp      pointer to a display
+ * @return          the size of the draw buffer in bytes for valid display, 0 otherwise
+ */
+uint32_t lv_display_get_draw_buf_size(lv_display_t * disp);
+
+/**
+ * Get the size of the invalidated draw buffer. Can be used in the flush callback
+ * to get the number of bytes used in the current render buffer.
+ * @param disp      pointer to a display
+ * @param width     the width of the invalidated area
+ * @param height    the height of the invalidated area
+ * @return          the size of the invalidated draw buffer in bytes, not accounting for
+ *                  any preceding palette information for a valid display, 0 otherwise
+ */
+uint32_t lv_display_get_invalidated_draw_buf_size(lv_display_t * disp, uint32_t width, uint32_t height);
+
+/**********************
+ *      MACROS
+ **********************/
+
+/*------------------------------------------------
+ * To improve backward compatibility
+ * Recommended only if you have one display
+ *------------------------------------------------*/
+
+#ifndef LV_HOR_RES
+/**
+ * The horizontal resolution of the currently active display.
+ */
+#define LV_HOR_RES lv_display_get_horizontal_resolution(lv_display_get_default())
+#endif
+
+#ifndef LV_VER_RES
+/**
+ * The vertical resolution of the currently active display.
+ */
+#define LV_VER_RES lv_display_get_vertical_resolution(lv_display_get_default())
+#endif
+
+/**
+ * See `lv_dpx()` and `lv_display_dpx()`.
+ * Same as Android's DIP. (Different name is chosen to avoid mistype between LV_DPI and LV_DIP)
+ *
+ * - 40 dip is 40 px on a 160 DPI screen (distance = 1/4 inch).
+ * - 40 dip is 80 px on a 320 DPI screen (distance still = 1/4 inch).
+ *
+ * @sa https://stackoverflow.com/questions/2025282/what-is-the-difference-between-px-dip-dp-and-sp
+ */
+#define LV_DPX_CALC(dpi, n)   ((n) == 0 ? 0 :LV_MAX((( (dpi) * (n) + 80) / 160), 1)) /*+80 for rounding*/
+#define LV_DPX(n)   LV_DPX_CALC(lv_display_get_dpi(NULL), n)
+
+/**
+ * For default display, computes the number of pixels (a distance or size) as if the
+ * display had 160 DPI.  This allows you to specify 1/160-th fractions of an inch to
+ * get real distance on the display that will be consistent regardless of its current
+ * DPI.  It ensures `lv_dpx(100)`, for example, will have the same physical size
+ * regardless to the DPI of the display.
+ * @param n     number of 1/160-th-inch units to compute with
+ * @return      number of pixels to use to make that distance
+ */
+int32_t lv_dpx(int32_t n);
+
+/**
+ * For specified display, computes the number of pixels (a distance or size) as if the
+ * display had 160 DPI.  This allows you to specify 1/160-th fractions of an inch to
+ * get real distance on the display that will be consistent regardless of its current
+ * DPI.  It ensures `lv_dpx(100)`, for example, will have the same physical size
+ * regardless to the DPI of the display.
+ * @param disp  pointer to display whose dpi should be considered
+ * @param n     number of 1/160-th-inch units to compute with
+ * @return      number of pixels to use to make that distance
+ */
+int32_t lv_display_dpx(const lv_display_t * disp, int32_t n);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DISPLAY_H*/

components/easylvgl/lvgl9/src/display/lv_display_private.h

@@ -0,0 +1,188 @@
+/**
+ * @file lv_display_private.h
+ *
+ */
+
+#ifndef LV_DISPLAY_PRIVATE_H
+#define LV_DISPLAY_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../core/lv_obj.h"
+#include "../draw/lv_draw.h"
+#include "lv_display.h"
+
+#if LV_USE_SYSMON
+#include "../others/sysmon/lv_sysmon_private.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifndef LV_INV_BUF_SIZE
+#define LV_INV_BUF_SIZE 32 /**< Buffer size for invalid areas */
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_display_t {
+
+    /*---------------------
+     * Resolution
+     *--------------------*/
+
+    /** Horizontal resolution.*/
+    int32_t hor_res;
+
+    /** Vertical resolution.*/
+    int32_t ver_res;
+
+    /** Horizontal resolution of the full / physical display. Set to -1 for fullscreen mode.*/
+    int32_t physical_hor_res;
+
+    /** Vertical resolution of the full / physical display. Set to -1 for fullscreen mode.*/
+    int32_t physical_ver_res;
+
+    /** Horizontal offset from the full / physical display. Set to 0 for fullscreen mode.*/
+    int32_t offset_x;
+
+    /** Vertical offset from the full / physical display. Set to 0 for fullscreen mode.*/
+    int32_t offset_y;
+
+    /** DPI (dot per inch) of the display. Default value is `LV_DPI_DEF`.*/
+    uint32_t dpi;
+
+    /*---------------------
+     * Buffering
+     *--------------------*/
+    lv_draw_buf_t * buf_1;
+    lv_draw_buf_t * buf_2;
+    lv_draw_buf_t * buf_3;
+
+    /** Internal, used by the library*/
+    lv_draw_buf_t * buf_act;
+
+    /** MANDATORY: Write the internal buffer (draw_buf) to the display. 'lv_display_flush_ready()' has to be
+     * called when finished*/
+    lv_display_flush_cb_t flush_cb;
+
+    /**
+     * Used to wait while flushing is ready.
+     * It can do any complex logic to wait, including semaphores, mutexes, polling flags, etc.
+     * If not set `flushing` flag is used which can be cleared with `lv_display_flush_ready()` */
+    lv_display_flush_wait_cb_t flush_wait_cb;
+
+    /** 1: flushing is in progress. (It can't be a bit field because when it's cleared from IRQ
+     * Read-Modify-Write issue might occur) */
+    volatile int flushing;
+
+    /** 1: It was the last chunk to flush. (It can't be a bit field because when it's cleared
+     * from IRQ Read-Modify-Write issue might occur) */
+    volatile int flushing_last;
+    volatile uint32_t last_area         : 1; /**< 1: last area is being rendered */
+    volatile uint32_t last_part         : 1; /**< 1: last part of the current area is being rendered */
+
+    lv_display_render_mode_t render_mode;
+    uint32_t antialiasing : 1;       /**< 1: anti-aliasing is enabled on this display.*/
+    uint32_t tile_cnt     : 8;       /**< Divide the display buffer into these number of tiles */
+    uint32_t stride_is_auto : 1;     /**< 1: The stride of the buffers was not set explicitly. */
+
+
+    /** 1: The current screen rendering is in progress*/
+    uint32_t rendering_in_progress : 1;
+
+    lv_color_format_t   color_format;
+
+    /** Invalidated (marked to redraw) areas*/
+    lv_area_t inv_areas[LV_INV_BUF_SIZE];
+    uint8_t inv_area_joined[LV_INV_BUF_SIZE];
+    uint32_t inv_p;
+    int32_t inv_en_cnt;
+
+    /** Double buffer sync areas (redrawn during last refresh) */
+    lv_ll_t sync_areas;
+
+    lv_draw_buf_t _static_buf1; /**< Used when user pass in a raw buffer as display draw buffer */
+    lv_draw_buf_t _static_buf2;
+    /*---------------------
+     * Layer
+     *--------------------*/
+    lv_layer_t * layer_head;
+    void (*layer_init)(lv_display_t * disp, lv_layer_t * layer);
+    void (*layer_deinit)(lv_display_t * disp, lv_layer_t * layer);
+
+    /*---------------------
+     * Screens
+     *--------------------*/
+
+    /** Screens of the display*/
+    lv_obj_t ** screens;    /**< Array of screen objects.*/
+    lv_obj_t * sys_layer;   /**< @see lv_display_get_layer_sys*/
+    lv_obj_t * top_layer;   /**< @see lv_display_get_layer_top*/
+    lv_obj_t * act_scr;     /**< Currently active screen on this display*/
+    lv_obj_t * bottom_layer;/**< @see lv_display_get_layer_bottom*/
+    lv_obj_t * prev_scr;    /**< Previous screen. Used during screen animations*/
+    lv_obj_t * scr_to_load; /**< The screen prepared to load in lv_screen_load_anim*/
+    uint32_t screen_cnt;
+    uint8_t draw_prev_over_act  : 1;/** 1: Draw previous screen over active screen*/
+    uint8_t del_prev  : 1;  /** 1: Automatically delete the previous screen when the screen load animation is ready*/
+
+    /*---------------------
+     * Others
+     *--------------------*/
+
+    void * driver_data; /**< Custom user data*/
+
+    void * user_data; /**< Custom user data*/
+
+    lv_event_list_t event_list;
+
+    uint32_t rotation  : 3; /**< Element of  lv_display_rotation_t*/
+
+    uint32_t matrix_rotation : 1; /**< 1: Use matrix for display rotation*/
+
+    lv_theme_t * theme;     /**< The theme assigned to the screen*/
+
+    /** A timer which periodically checks the dirty areas and refreshes them*/
+    lv_timer_t * refr_timer;
+
+    /*Miscellaneous data*/
+    uint32_t last_activity_time;        /**< Last time when there was activity on this display*/
+
+    /** The area being refreshed*/
+    lv_area_t refreshed_area;
+    uint32_t vsync_count;
+
+#if LV_USE_PERF_MONITOR
+    lv_obj_t * perf_label;
+    lv_sysmon_backend_data_t perf_sysmon_backend;
+    lv_sysmon_perf_info_t perf_sysmon_info;
+#endif
+
+#if LV_USE_MEM_MONITOR
+    lv_obj_t * mem_label;
+#endif
+
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DISPLAY_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/convert/helium/lv_draw_buf_convert_helium.c

@@ -0,0 +1,100 @@
+/**
+ * @file lv_draw_buf_convert_helium.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lv_conf_internal.h"
+
+#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_HELIUM
+#include "lv_draw_buf_convert_helium.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t _lv_draw_buf_convert_premultiply_indexed_helium(lv_draw_buf_t * buf)
+{
+    lv_draw_buf_t palette_draw_buf;
+
+    LV_ASSERT_NULL(buf);
+
+    if(!LV_COLOR_FORMAT_IS_INDEXED(buf->header.cf)) {
+        LV_LOG_WARN("Unsupported color format : %d", buf->header.cf);
+        return LV_RESULT_INVALID;
+    }
+
+    lv_memcpy(&palette_draw_buf, buf, sizeof(lv_draw_buf_t));
+
+    palette_draw_buf.header.w = LV_COLOR_INDEXED_PALETTE_SIZE(buf->header.cf);
+    palette_draw_buf.header.h = 1;
+    palette_draw_buf.header.cf = LV_COLOR_FORMAT_ARGB8888;
+    palette_draw_buf.header.stride = 4 * palette_draw_buf.header.w;
+
+    return _lv_draw_buf_convert_premultiply_argb8888_helium(&palette_draw_buf);
+}
+
+lv_result_t _lv_draw_buf_convert_premultiply_argb8888_helium(lv_draw_buf_t * buf)
+{
+    LV_ASSERT_NULL(buf);
+
+    uint32_t h = buf->header.h;
+    uint32_t w = buf->header.w;
+    uint32_t stride = buf->header.stride;
+    uint8_t * data = (uint8_t *)buf->data;
+
+    if(buf->header.cf != LV_COLOR_FORMAT_ARGB8888) {
+        LV_LOG_WARN("Unsupported color format : %d", buf->header.cf);
+        return LV_RESULT_INVALID;
+    }
+
+    __asm volatile(
+        "   .p2align 2                                                  \n"
+        "   1:                                                          \n"
+        "   mov                     r0, %[pSource]                      \n"
+        "   mov                     r1, %[pTarget]                      \n"
+        "   wlstp.8                 lr, %[w], 3f                        \n"
+        "   2:                                                          \n"
+        "   vld40.u8                {q0, q1, q2, q3}, [r0]              \n"
+        "   vld41.u8                {q0, q1, q2, q3}, [r0]              \n"
+        "   vld42.u8                {q0, q1, q2, q3}, [r0]              \n"
+        "   vld43.u8                {q0, q1, q2, q3}, [r0]!             \n"
+        "   vrmulh.u8               q0, q0, q3                          \n"
+        "   vrmulh.u8               q1, q1, q3                          \n"
+        "   vrmulh.u8               q2, q2, q3                          \n"
+        "   vst40.u8                {q0, q1, q2, q3}, [r1]              \n"
+        "   vst41.u8                {q0, q1, q2, q3}, [r1]              \n"
+        "   vst42.u8                {q0, q1, q2, q3}, [r1]              \n"
+        "   vst43.u8                {q0, q1, q2, q3}, [r1]!             \n"
+        "   letp                    lr, 2b                              \n"
+        "   3:                                                          \n"
+        "   adds                    %[pSource], %[src_stride]           \n"
+        "   adds                    %[pTarget], %[dst_stride]           \n"
+        "   subs                    %[h], #1                            \n"
+        "   bne                     1b                                  \n"
+        : [pSource] "+r"(data), [pTarget] "+r"(data), [h] "+r"(h)
+        : [w] "r"(w), [src_stride] "r"(stride), [dst_stride] "r"(stride)
+        : "q0", "q1", "q2", "q3", "r0", "r1", "lr", "memory");
+
+    return LV_RESULT_OK;
+}
+
+#endif  /* LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_HELIUM */

components/easylvgl/lvgl9/src/draw/convert/helium/lv_draw_buf_convert_helium.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_draw_buf_convert_helium.h
+ *
+ */
+
+#ifndef LV_DRAW_BUF_CONVERT_HELIUM_H
+#define LV_DRAW_BUF_CONVERT_HELIUM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../../misc/lv_color.h"
+#include "../../lv_draw_buf.h"
+
+#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_HELIUM
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_INDEXED
+#define LV_DRAW_CONVERT_PREMULTIPLY_INDEXED(buf) \
+    _lv_draw_buf_convert_premultiply_indexed_helium(buf)
+#endif
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888
+#define LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888(buf) \
+    _lv_draw_buf_convert_premultiply_argb8888_helium(buf)
+#endif
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Convert indexed draw_buf to premultiplied format with helium specific optimizations
+ * @param buf     pointer to a draw buf
+ */
+lv_result_t _lv_draw_buf_convert_premultiply_indexed_helium(lv_draw_buf_t * buf);
+
+/**
+ * Convert argb8888 draw_buf to premultiplied format with helium specific optimizations
+ * @param buf     pointer to a draw buf
+ */
+lv_result_t _lv_draw_buf_convert_premultiply_argb8888_helium(lv_draw_buf_t * buf);
+
+#endif /*LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_HELIUM*/
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV_DRAW_BUF_CONVERT_HELIUM_H */

components/easylvgl/lvgl9/src/draw/convert/lv_draw_buf_convert.c

@@ -0,0 +1,130 @@
+/**
+ * @file lv_draw_buf_convert.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_buf_convert.h"
+
+#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_NEON
+    #include "neon/lv_draw_buf_convert_neon.h"
+#elif LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_HELIUM
+    #include "helium/lv_draw_buf_convert_helium.h"
+#elif LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_CUSTOM
+    #include LV_DRAW_SW_ASM_CUSTOM_INCLUDE
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_INDEXED
+    #define LV_DRAW_CONVERT_PREMULTIPLY_INDEXED(...)                         LV_RESULT_INVALID
+#endif
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888
+    #define LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888(...)                         LV_RESULT_INVALID
+#endif
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_RGB565A8
+    #define LV_DRAW_CONVERT_PREMULTIPLY_RGB565A8(...)                         LV_RESULT_INVALID
+#endif
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_ARGB8565
+    #define LV_DRAW_CONVERT_PREMULTIPLY_ARGB8565(...)                         LV_RESULT_INVALID
+#endif
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t lv_draw_buf_convert_premultiply(lv_draw_buf_t * draw_buf)
+{
+    LV_ASSERT_NULL(draw_buf);
+
+    /*Premultiply color with alpha, do case by case by judging color format*/
+    lv_color_format_t cf = draw_buf->header.cf;
+    if(LV_COLOR_FORMAT_IS_INDEXED(cf)) {
+        if(LV_RESULT_INVALID == LV_DRAW_CONVERT_PREMULTIPLY_INDEXED(draw_buf)) {
+            int size = LV_COLOR_INDEXED_PALETTE_SIZE(cf);
+            lv_color32_t * palette = (lv_color32_t *)draw_buf->data;
+            for(int i = 0; i < size; i++) {
+                lv_color_premultiply(&palette[i]);
+            }
+        }
+    }
+    else if(cf == LV_COLOR_FORMAT_ARGB8888) {
+        if(LV_RESULT_INVALID == LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888(draw_buf)) {
+            uint32_t h = draw_buf->header.h;
+            uint32_t w = draw_buf->header.w;
+            uint32_t stride = draw_buf->header.stride;
+            uint8_t * line = (uint8_t *)draw_buf->data;
+            for(uint32_t y = 0; y < h; y++) {
+                lv_color32_t * pixel = (lv_color32_t *)line;
+                for(uint32_t x = 0; x < w; x++) {
+                    lv_color_premultiply(pixel);
+                    pixel++;
+                }
+                line += stride;
+            }
+        }
+    }
+    else if(cf == LV_COLOR_FORMAT_RGB565A8) {
+        if(LV_RESULT_INVALID == LV_DRAW_CONVERT_PREMULTIPLY_RGB565A8(draw_buf)) {
+            uint32_t h = draw_buf->header.h;
+            uint32_t w = draw_buf->header.w;
+            uint32_t stride = draw_buf->header.stride;
+            uint32_t alpha_stride = stride / 2;
+            uint8_t * line = (uint8_t *)draw_buf->data;
+            lv_opa_t * alpha = (lv_opa_t *)(line + stride * h);
+            for(uint32_t y = 0; y < h; y++) {
+                lv_color16_t * pixel = (lv_color16_t *)line;
+                for(uint32_t x = 0; x < w; x++) {
+                    lv_color16_premultiply(pixel, alpha[x]);
+                    pixel++;
+                }
+                line += stride;
+                alpha += alpha_stride;
+            }
+        }
+    }
+    else if(cf == LV_COLOR_FORMAT_ARGB8565) {
+        if(LV_RESULT_INVALID == LV_DRAW_CONVERT_PREMULTIPLY_ARGB8565(draw_buf)) {
+            uint32_t h = draw_buf->header.h;
+            uint32_t w = draw_buf->header.w;
+            uint32_t stride = draw_buf->header.stride;
+            uint8_t * line = (uint8_t *)draw_buf->data;
+            for(uint32_t y = 0; y < h; y++) {
+                uint8_t * pixel = line;
+                for(uint32_t x = 0; x < w; x++) {
+                    uint8_t alpha = pixel[2];
+                    lv_color16_premultiply((lv_color16_t *)pixel, alpha);
+                    pixel += 3;
+                }
+                line += stride;
+            }
+        }
+    }
+    else if(LV_COLOR_FORMAT_IS_ALPHA_ONLY(cf)) {
+        /*Pass*/
+    }
+    else {
+        LV_LOG_WARN("draw buf has no alpha, cf: %d", cf);
+    }
+
+    return LV_RESULT_OK;
+}

components/easylvgl/lvgl9/src/draw/convert/lv_draw_buf_convert.h

@@ -0,0 +1,39 @@
+/**
+ * @file lv_draw_buf_convert.h
+ *
+ */
+
+#ifndef LV_DRAW_BUF_CONVERT_H
+#define LV_DRAW_BUF_CONVERT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../misc/lv_color.h"
+#include "../lv_draw_buf.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Convert draw_buf  to premultiplied format
+ * @param buf     pointer to a draw buf
+ */
+lv_result_t lv_draw_buf_convert_premultiply(lv_draw_buf_t * buf);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV_DRAW_BUF_CONVERT_H */

components/easylvgl/lvgl9/src/draw/convert/neon/lv_draw_buf_convert_neon.c

@@ -0,0 +1,132 @@
+/**
+ * @file lv_draw_buf_convert_neon.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lv_conf_internal.h"
+
+#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_NEON
+
+#include <arm_neon.h>
+#include "lv_draw_buf_convert_neon.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t _lv_draw_buf_convert_premultiply_indexed_neon(lv_draw_buf_t * buf)
+{
+    lv_draw_buf_t palette_draw_buf;
+
+    LV_ASSERT_NULL(buf);
+
+    if(!LV_COLOR_FORMAT_IS_INDEXED(buf->header.cf)) {
+        LV_LOG_WARN("Unsupported color format : %d", buf->header.cf);
+        return LV_RESULT_INVALID;
+    }
+
+    lv_memcpy(&palette_draw_buf, buf, sizeof(lv_draw_buf_t));
+
+    palette_draw_buf.header.w = LV_COLOR_INDEXED_PALETTE_SIZE(buf->header.cf);
+    palette_draw_buf.header.h = 1;
+    palette_draw_buf.header.cf = LV_COLOR_FORMAT_ARGB8888;
+    palette_draw_buf.header.stride = 4 * palette_draw_buf.header.w;
+
+    return _lv_draw_buf_convert_premultiply_argb8888_neon(&palette_draw_buf);
+
+}
+
+lv_result_t _lv_draw_buf_convert_premultiply_argb8888_neon(lv_draw_buf_t * buf)
+{
+    LV_ASSERT_NULL(buf);
+
+    uint32_t h = buf->header.h;
+    uint32_t w = buf->header.w;
+    uint32_t stride = buf->header.stride;
+    uint8_t * data = (uint8_t *)buf->data;
+
+    if(buf->header.cf != LV_COLOR_FORMAT_ARGB8888) {
+        LV_LOG_WARN("Unsupported color format : %d", buf->header.cf);
+        return LV_RESULT_INVALID;
+    }
+
+    for(uint32_t y = 0; y < h; y++) {
+        uint8_t * p = (uint8_t *)data;
+        uint32_t remaining_pixels = w;
+
+        while(remaining_pixels >= 8) {
+            uint8x8x4_t rgba = vld4_u8(p);
+
+            uint16x8_t r16 = vmovl_u8(rgba.val[0]);
+            uint16x8_t g16 = vmovl_u8(rgba.val[1]);
+            uint16x8_t b16 = vmovl_u8(rgba.val[2]);
+            uint16x8_t a16 = vmovl_u8(rgba.val[3]);
+
+            rgba.val[0] = vshrn_n_u16(vmulq_u16(r16, a16), 8);
+            rgba.val[1] = vshrn_n_u16(vmulq_u16(g16, a16), 8);
+            rgba.val[2] = vshrn_n_u16(vmulq_u16(b16, a16), 8);
+
+            vst4_u8(p, rgba);
+
+            p += 8 * 4;
+            remaining_pixels -= 8;
+        }
+
+        if(remaining_pixels >= 4) {
+            uint8x8x4_t rgba;
+            rgba = vld4_lane_u8(p, rgba, 0);
+            rgba = vld4_lane_u8(p + 4, rgba, 1);
+            rgba = vld4_lane_u8(p + 8, rgba, 2);
+            rgba = vld4_lane_u8(p + 12, rgba, 3);
+
+            uint16x8_t r16 = vmovl_u8(rgba.val[0]);
+            uint16x8_t g16 = vmovl_u8(rgba.val[1]);
+            uint16x8_t b16 = vmovl_u8(rgba.val[2]);
+            uint16x8_t a16 = vmovl_u8(rgba.val[3]);
+
+            rgba.val[0] = vshrn_n_u16(vmulq_u16(r16, a16), 8);
+            rgba.val[1] = vshrn_n_u16(vmulq_u16(g16, a16), 8);
+            rgba.val[2] = vshrn_n_u16(vmulq_u16(b16, a16), 8);
+
+            vst4_lane_u8(p, rgba, 0);
+            vst4_lane_u8(p + 4, rgba, 1);
+            vst4_lane_u8(p + 8, rgba, 2);
+            vst4_lane_u8(p + 12, rgba, 3);
+
+            p += 4 * 4;
+            remaining_pixels -= 4;
+        }
+
+        while(remaining_pixels--) {
+            uint8_t a = p[3];
+            p[0] = ((uint16_t)(p[0]) * a) >> 8;
+            p[1] = ((uint16_t)(p[1]) * a) >> 8;
+            p[2] = ((uint16_t)(p[2]) * a) >> 8;
+            p += 4;
+        }
+
+        data += stride;
+    }
+
+    return LV_RESULT_OK;
+}
+#endif /* LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_NEON */

components/easylvgl/lvgl9/src/draw/convert/neon/lv_draw_buf_convert_neon.h

@@ -0,0 +1,58 @@
+/**
+ * @file lv_draw_buf_convert_neon.h
+ *
+ */
+
+#ifndef LV_DRAW_BUF_CONVERT_NEON_H
+#define LV_DRAW_BUF_CONVERT_NEON_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../../misc/lv_color.h"
+#include "../../lv_draw_buf.h"
+
+#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_NEON
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_INDEXED
+#define LV_DRAW_CONVERT_PREMULTIPLY_INDEXED(buf) \
+    _lv_draw_buf_convert_premultiply_indexed_neon(buf)
+#endif
+
+#ifndef LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888
+#define LV_DRAW_CONVERT_PREMULTIPLY_ARGB8888(buf) \
+    _lv_draw_buf_convert_premultiply_argb8888_neon(buf)
+#endif
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Convert indexed draw_buf to premultiplied format with neon specific optimizations
+ * @param buf     pointer to a draw buf
+ */
+
+lv_result_t _lv_draw_buf_convert_premultiply_indexed_neon(lv_draw_buf_t * buf);
+
+/**
+ * Convert argb8888 draw_buf to premultiplied format with neon specific optimizations
+ * @param buf     pointer to a draw buf
+ */
+lv_result_t _lv_draw_buf_convert_premultiply_argb8888_neon(lv_draw_buf_t * buf);
+#endif /*LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_NEON*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV_DRAW_BUF_CONVERT_NEON_H */

components/easylvgl/lvgl9/src/draw/dma2d/lv_draw_dma2d.c

@@ -0,0 +1,394 @@
+/**
+ * @file lv_draw_dma2d.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_dma2d_private.h"
+#if LV_USE_DRAW_DMA2D
+
+#include "../sw/lv_draw_sw.h"
+#include "../../misc/lv_area_private.h"
+
+#if !LV_DRAW_DMA2D_ASYNC && LV_USE_DRAW_DMA2D_INTERRUPT
+    #warning LV_USE_DRAW_DMA2D_INTERRUPT is 1 but has no effect because LV_USE_OS is LV_OS_NONE
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define DRAW_UNIT_ID_DMA2D 5
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static int32_t evaluate_cb(lv_draw_unit_t * draw_unit, lv_draw_task_t * task);
+static int32_t dispatch_cb(lv_draw_unit_t * draw_unit, lv_layer_t * layer);
+static int32_t delete_cb(lv_draw_unit_t * draw_unit);
+#if LV_DRAW_DMA2D_ASYNC
+    static int32_t wait_finish_cb(lv_draw_unit_t * u);
+#endif
+#if !LV_DRAW_DMA2D_ASYNC
+    static bool check_transfer_completion(void);
+#endif
+static void post_transfer_tasks(lv_draw_dma2d_unit_t * u);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+#if LV_DRAW_DMA2D_ASYNC
+    static lv_draw_dma2d_unit_t * g_unit;
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_dma2d_init(void)
+{
+    lv_draw_dma2d_unit_t * draw_dma2d_unit = lv_draw_create_unit(sizeof(lv_draw_dma2d_unit_t));
+    draw_dma2d_unit->base_unit.evaluate_cb = evaluate_cb;
+    draw_dma2d_unit->base_unit.dispatch_cb = dispatch_cb;
+    draw_dma2d_unit->base_unit.delete_cb = delete_cb;
+#if LV_DRAW_DMA2D_ASYNC
+    draw_dma2d_unit->base_unit.wait_for_finish_cb = wait_finish_cb;
+#endif
+    draw_dma2d_unit->base_unit.name = "DMA2D";
+
+#if LV_DRAW_DMA2D_ASYNC
+    g_unit = draw_dma2d_unit;
+    lv_thread_sync_init(&draw_dma2d_unit->interrupt_signal);
+#endif
+
+    /* enable the DMA2D clock */
+#if defined(STM32F4) || defined(STM32F7) || defined(STM32U5) || defined(STM32L4)
+    RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN;
+#elif defined(STM32H7)
+    RCC->AHB3ENR |= RCC_AHB3ENR_DMA2DEN;
+#elif defined(STM32H7RS) || defined(STM32N6)
+    RCC->AHB5ENR |= RCC_AHB5ENR_DMA2DEN;
+#else
+#warning "LVGL can't enable the clock for DMA2D"
+#endif
+
+    /* disable dead time */
+    DMA2D->AMTCR = 0;
+
+    /* enable the interrupt */
+    NVIC_EnableIRQ(DMA2D_IRQn);
+}
+
+void lv_draw_dma2d_deinit(void)
+{
+    /* disable the interrupt */
+    NVIC_DisableIRQ(DMA2D_IRQn);
+
+    /* disable the DMA2D clock */
+#if defined(STM32F4) || defined(STM32F7) || defined(STM32U5) || defined(STM32L4)
+    RCC->AHB1ENR &= ~RCC_AHB1ENR_DMA2DEN;
+#elif defined(STM32H7)
+    RCC->AHB3ENR &= ~RCC_AHB3ENR_DMA2DEN;
+#elif defined(STM32H7RS) || defined(STM32N6)
+    RCC->AHB5ENR &= ~RCC_AHB5ENR_DMA2DEN;
+#endif
+
+#if LV_DRAW_DMA2D_ASYNC
+    lv_result_t res = lv_thread_sync_delete(&g_unit->interrupt_signal);
+    LV_ASSERT(res == LV_RESULT_OK);
+
+    g_unit = NULL;
+#endif
+}
+
+#if LV_USE_DRAW_DMA2D_INTERRUPT
+void lv_draw_dma2d_transfer_complete_interrupt_handler(void)
+{
+#if LV_DRAW_DMA2D_ASYNC
+    lv_thread_sync_signal_isr(&g_unit->interrupt_signal);
+#endif
+}
+#endif
+
+lv_draw_dma2d_output_cf_t lv_draw_dma2d_cf_to_dma2d_output_cf(lv_color_format_t cf)
+{
+    switch(cf) {
+        case LV_COLOR_FORMAT_ARGB8888:
+        case LV_COLOR_FORMAT_XRGB8888:
+            return LV_DRAW_DMA2D_OUTPUT_CF_ARGB8888;
+        case LV_COLOR_FORMAT_RGB888:
+            return LV_DRAW_DMA2D_OUTPUT_CF_RGB888;
+        case LV_COLOR_FORMAT_RGB565:
+            return LV_DRAW_DMA2D_OUTPUT_CF_RGB565;
+        case LV_COLOR_FORMAT_ARGB1555:
+            return LV_DRAW_DMA2D_OUTPUT_CF_ARGB1555;
+        default:
+            LV_ASSERT_MSG(false, "unsupported output color format");
+    }
+    return LV_DRAW_DMA2D_OUTPUT_CF_RGB565;
+}
+
+uint32_t lv_draw_dma2d_color_to_dma2d_color(lv_draw_dma2d_output_cf_t cf, lv_color_t color)
+{
+    switch(cf) {
+        case LV_DRAW_DMA2D_OUTPUT_CF_ARGB8888:
+        case LV_DRAW_DMA2D_OUTPUT_CF_RGB888:
+            return lv_color_to_u32(color);
+        case LV_DRAW_DMA2D_OUTPUT_CF_RGB565:
+            return lv_color_to_u16(color);
+        default:
+            LV_ASSERT_MSG(false, "unsupported output color format");
+    }
+    return 0;
+}
+
+void lv_draw_dma2d_configure_and_start_transfer(const lv_draw_dma2d_configuration_t * conf)
+{
+    /* number of lines register */
+    DMA2D->NLR = (conf->w << DMA2D_NLR_PL_Pos) | (conf->h << DMA2D_NLR_NL_Pos);
+
+    /* output */
+
+    /* output memory address register */
+    DMA2D->OMAR = (uint32_t)(uintptr_t) conf->output_address;
+    /* output offset register */
+    DMA2D->OOR = conf->output_offset;
+    /* output pixel format converter control register */
+    DMA2D->OPFCCR = ((uint32_t) conf->output_cf) << DMA2D_OPFCCR_CM_Pos;
+
+    /* Fill color. Only for mode LV_DRAW_DMA2D_MODE_REGISTER_TO_MEMORY */
+    DMA2D->OCOLR = conf->reg_to_mem_mode_color;
+
+    /* foreground */
+
+    /* foreground memory address register */
+    DMA2D->FGMAR = (uint32_t)(uintptr_t) conf->fg_address;
+    /* foreground offset register */
+    DMA2D->FGOR = conf->fg_offset;
+    /* foreground color. only for mem-to-mem with blending and fixed-color foreground */
+    DMA2D->FGCOLR = conf->fg_color;
+    /* foreground pixel format converter control register */
+    DMA2D->FGPFCCR = (((uint32_t) conf->fg_cf) << DMA2D_FGPFCCR_CM_Pos)
+                     | (conf->fg_alpha << DMA2D_FGPFCCR_ALPHA_Pos)
+                     | (conf->fg_alpha_mode << DMA2D_FGPFCCR_AM_Pos);
+
+    /* background */
+
+    DMA2D->BGMAR = (uint32_t)(uintptr_t) conf->bg_address;
+    DMA2D->BGOR = conf->bg_offset;
+    DMA2D->BGCOLR = conf->bg_color;
+    DMA2D->BGPFCCR = (((uint32_t) conf->bg_cf) << DMA2D_BGPFCCR_CM_Pos)
+                     | (conf->bg_alpha << DMA2D_BGPFCCR_ALPHA_Pos)
+                     | (conf->bg_alpha_mode << DMA2D_BGPFCCR_AM_Pos);
+
+    /* ensure the DMA2D register values are observed before the start transfer bit is set */
+    __DSB();
+
+    /* start the transfer (also set mode and enable transfer complete interrupt) */
+    DMA2D->CR = DMA2D_CR_START | (((uint32_t) conf->mode) << DMA2D_CR_MODE_Pos)
+#if LV_USE_DRAW_DMA2D_INTERRUPT
+                | DMA2D_CR_TCIE
+#endif
+                ;
+}
+
+#if LV_DRAW_DMA2D_CACHE
+void lv_draw_dma2d_invalidate_cache(const lv_draw_dma2d_cache_area_t * mem_area)
+{
+    if(SCB->CCR & SCB_CCR_DC_Msk) {
+        SCB_InvalidateDCache();
+    }
+}
+
+void lv_draw_dma2d_clean_cache(const lv_draw_dma2d_cache_area_t * mem_area)
+{
+    if(SCB->CCR & SCB_CCR_DC_Msk) {
+        SCB_CleanDCache();
+    }
+}
+#endif
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static int32_t evaluate_cb(lv_draw_unit_t * draw_unit, lv_draw_task_t * task)
+{
+    switch(task->type) {
+        case LV_DRAW_TASK_TYPE_FILL: {
+                lv_draw_fill_dsc_t * dsc = task->draw_dsc;
+                if(!(dsc->radius == 0
+                     && dsc->grad.dir == LV_GRAD_DIR_NONE
+                     && (dsc->base.layer->color_format == LV_COLOR_FORMAT_ARGB8888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_XRGB8888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB565))) {
+                    return 0;
+                }
+            }
+            break;
+        case LV_DRAW_TASK_TYPE_IMAGE: {
+                lv_draw_image_dsc_t * dsc = task->draw_dsc;
+                if(!(dsc->header.cf < LV_COLOR_FORMAT_PROPRIETARY_START
+                     && dsc->clip_radius == 0
+                     && dsc->bitmap_mask_src == NULL
+                     && dsc->sup == NULL
+                     && dsc->tile == 0
+                     && dsc->blend_mode == LV_BLEND_MODE_NORMAL
+                     && dsc->recolor_opa <= LV_OPA_MIN
+                     && dsc->skew_y == 0
+                     && dsc->skew_x == 0
+                     && dsc->scale_x == 256
+                     && dsc->scale_y == 256
+                     && dsc->rotation == 0
+                     && lv_image_src_get_type(dsc->src) == LV_IMAGE_SRC_VARIABLE
+                     && (dsc->header.cf == LV_COLOR_FORMAT_ARGB8888
+                         || dsc->header.cf == LV_COLOR_FORMAT_XRGB8888
+                         || dsc->header.cf == LV_COLOR_FORMAT_RGB888
+                         || dsc->header.cf == LV_COLOR_FORMAT_RGB565
+                         || dsc->header.cf == LV_COLOR_FORMAT_ARGB1555)
+                     && (dsc->base.layer->color_format == LV_COLOR_FORMAT_ARGB8888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_XRGB8888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB565))) {
+                    return 0;
+                }
+            }
+            break;
+        default:
+            return 0;
+    }
+
+    task->preferred_draw_unit_id = DRAW_UNIT_ID_DMA2D;
+    task->preference_score = 0;
+
+    return 0;
+}
+
+static int32_t dispatch_cb(lv_draw_unit_t * draw_unit, lv_layer_t * layer)
+{
+    lv_draw_dma2d_unit_t * draw_dma2d_unit = (lv_draw_dma2d_unit_t *) draw_unit;
+
+    if(draw_dma2d_unit->task_act) {
+#if LV_DRAW_DMA2D_ASYNC
+        /*Return immediately if it's busy with draw task*/
+        return LV_DRAW_UNIT_IDLE;
+#else
+        if(!check_transfer_completion()) {
+            return LV_DRAW_UNIT_IDLE;
+        }
+        post_transfer_tasks(draw_dma2d_unit);
+#endif
+    }
+
+    lv_draw_task_t * t = lv_draw_get_available_task(layer, NULL, DRAW_UNIT_ID_DMA2D);
+    if(t == NULL) {
+        return LV_DRAW_UNIT_IDLE;
+    }
+
+    void * buf = lv_draw_layer_alloc_buf(layer);
+    if(buf == NULL) {
+        return LV_DRAW_UNIT_IDLE;
+    }
+
+    t->state = LV_DRAW_TASK_STATE_IN_PROGRESS;
+    t->draw_unit = draw_unit;
+    draw_dma2d_unit->task_act = t;
+
+    if(t->type == LV_DRAW_TASK_TYPE_FILL) {
+        lv_draw_fill_dsc_t * dsc = t->draw_dsc;
+        const lv_area_t * coords = &t->area;
+        lv_area_t clipped_coords;
+        if(!lv_area_intersect(&clipped_coords, coords, &t->clip_area)) {
+            return LV_DRAW_UNIT_IDLE;
+        }
+
+        void * dest = lv_draw_layer_go_to_xy(layer,
+                                             clipped_coords.x1 - layer->buf_area.x1,
+                                             clipped_coords.y1 - layer->buf_area.y1);
+
+        if(dsc->opa >= LV_OPA_MAX) {
+            lv_draw_dma2d_opaque_fill(t,
+                                      dest,
+                                      lv_area_get_width(&clipped_coords),
+                                      lv_area_get_height(&clipped_coords),
+                                      lv_draw_buf_width_to_stride(lv_area_get_width(&layer->buf_area), dsc->base.layer->color_format));
+        }
+        else {
+            lv_draw_dma2d_fill(t,
+                               dest,
+                               lv_area_get_width(&clipped_coords),
+                               lv_area_get_height(&clipped_coords),
+                               lv_draw_buf_width_to_stride(lv_area_get_width(&layer->buf_area), dsc->base.layer->color_format));
+        }
+    }
+    else if(t->type == LV_DRAW_TASK_TYPE_IMAGE) {
+        lv_draw_image_dsc_t * dsc = t->draw_dsc;
+        const lv_area_t * coords = &t->area;
+        lv_area_t clipped_coords;
+        if(!lv_area_intersect(&clipped_coords, coords, &t->clip_area)) {
+            return LV_DRAW_UNIT_IDLE;
+        }
+
+        if(dsc->opa >= LV_OPA_MAX) {
+            lv_draw_dma2d_opaque_image(t, dsc, &t->area);
+        }
+        else {
+            lv_draw_dma2d_image(t, dsc, &t->area);
+        }
+    }
+
+    lv_draw_dispatch_request();
+
+    return 1;
+}
+
+static int32_t delete_cb(lv_draw_unit_t * draw_unit)
+{
+    return 0;
+}
+
+#if LV_DRAW_DMA2D_ASYNC
+static int32_t wait_finish_cb(lv_draw_unit_t * draw_unit)
+{
+    lv_draw_dma2d_unit_t * u = (lv_draw_dma2d_unit_t *) draw_unit;
+
+    /* If a DMA2D task has been dispatched, wait its interrupt */
+    lv_thread_sync_wait(&u->interrupt_signal);
+
+    /* Then cleanup the DMA2D draw unit to accept a new task */
+    post_transfer_tasks(u);
+    return 0;
+}
+#endif /*LV_DRAW_DMA2D_ASYNC*/
+
+#if !LV_DRAW_DMA2D_ASYNC
+static bool check_transfer_completion(void)
+{
+    return !(DMA2D->CR & DMA2D_CR_START);
+}
+#endif
+
+static void post_transfer_tasks(lv_draw_dma2d_unit_t * u)
+{
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_invalidate_cache(&u->writing_area);
+#endif
+    u->task_act->state = LV_DRAW_TASK_STATE_FINISHED;
+    u->task_act = NULL;
+}
+
+#endif /*LV_USE_DRAW_DMA2D*/

components/easylvgl/lvgl9/src/draw/dma2d/lv_draw_dma2d.h

@@ -0,0 +1,49 @@
+/**
+ * @file lv_draw_dma2d.h
+ *
+ */
+
+#ifndef LV_DRAW_DMA2D_H
+#define LV_DRAW_DMA2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_DRAW_DMA2D
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_dma2d_init(void);
+void lv_draw_dma2d_deinit(void);
+
+#if LV_USE_DRAW_DMA2D_INTERRUPT
+void lv_draw_dma2d_transfer_complete_interrupt_handler(void);
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_DRAW_DMA2D*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_DMA2D_H*/

components/easylvgl/lvgl9/src/draw/dma2d/lv_draw_dma2d_fill.c

@@ -0,0 +1,133 @@
+/**
+ * @file lv_draw_dma2d_fill.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_dma2d_private.h"
+#if LV_USE_DRAW_DMA2D
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_dma2d_opaque_fill(lv_draw_task_t * t, void * first_pixel, int32_t w, int32_t h, int32_t stride)
+{
+    lv_draw_fill_dsc_t * dsc = t->draw_dsc;
+    lv_color_format_t cf = dsc->base.layer->color_format;
+
+    lv_draw_dma2d_output_cf_t output_cf = lv_draw_dma2d_cf_to_dma2d_output_cf(cf);
+    uint32_t cf_size = LV_COLOR_FORMAT_GET_SIZE(cf);
+    uint32_t reg_to_mem_color = lv_draw_dma2d_color_to_dma2d_color(output_cf, dsc->color);
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t cache_area = {
+        .first_byte = first_pixel,
+        .width_bytes = w * cf_size,
+        .height = h,
+        .stride = stride
+    };
+    lv_draw_dma2d_unit_t * u = (lv_draw_dma2d_unit_t *) t->draw_unit;
+    lv_memcpy(&u->writing_area, &cache_area, sizeof(lv_draw_dma2d_cache_area_t));
+#endif
+
+    lv_draw_dma2d_configuration_t conf = {
+        .mode = LV_DRAW_DMA2D_MODE_REGISTER_TO_MEMORY,
+        .w = w,
+        .h = h,
+
+        .output_address = first_pixel,
+        .output_offset = (stride / cf_size) - w,
+        .output_cf = output_cf,
+
+        .reg_to_mem_mode_color = reg_to_mem_color
+    };
+    lv_draw_dma2d_configure_and_start_transfer(&conf);
+}
+
+void lv_draw_dma2d_fill(lv_draw_task_t * t, void * first_pixel, int32_t w, int32_t h, int32_t stride)
+{
+    lv_draw_fill_dsc_t * dsc = t->draw_dsc;
+    lv_color_t color = dsc->color;
+    lv_color_format_t cf = dsc->base.layer->color_format;
+    lv_opa_t opa = dsc->opa;
+
+    lv_draw_dma2d_output_cf_t output_cf = lv_draw_dma2d_cf_to_dma2d_output_cf(cf);
+    uint32_t cf_size = LV_COLOR_FORMAT_GET_SIZE(cf);
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t cache_area = {
+        .first_byte = first_pixel,
+        .width_bytes = w * cf_size,
+        .height = h,
+        .stride = stride
+    };
+    lv_draw_dma2d_unit_t * u = (lv_draw_dma2d_unit_t *) t->draw_unit;
+    lv_memcpy(&u->writing_area, &cache_area, sizeof(lv_draw_dma2d_cache_area_t));
+
+    /* make sure the background area DMA2D is blending is up-to-date in main memory */
+    lv_draw_dma2d_clean_cache(&cache_area);
+#endif
+
+    uint32_t output_offset = (stride / cf_size) - w;
+
+    lv_draw_dma2d_configuration_t conf = {
+        .mode = LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING,
+        .w = w,
+        .h = h,
+
+        .output_address = first_pixel,
+        .output_offset = output_offset,
+        .output_cf = output_cf,
+
+        .fg_color = lv_color_to_u32(color),
+        .fg_address = first_pixel,
+        .fg_offset = output_offset,
+        .fg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL,
+        .fg_alpha = opa,
+        .fg_cf = LV_DRAW_DMA2D_FGBG_CF_A8,
+
+        .bg_address = first_pixel,
+        .bg_offset = output_offset,
+        .bg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_NO_MODIFY_IMAGE_ALPHA_CHANNEL,
+        .bg_alpha = opa,
+        .bg_cf = (lv_draw_dma2d_fgbg_cf_t) output_cf
+    };
+
+    /* Background alpha channel should be treated as 0xFF if the cf is XRGB */
+    if(cf == LV_COLOR_FORMAT_XRGB8888) {
+        conf.bg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL;
+        conf.bg_alpha = 0xff;
+    }
+
+    lv_draw_dma2d_configure_and_start_transfer(&conf);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_DRAW_DMA2D*/

components/easylvgl/lvgl9/src/draw/dma2d/lv_draw_dma2d_img.c

@@ -0,0 +1,262 @@
+/**
+ * @file lv_draw_dma2d_img.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_dma2d_private.h"
+#if LV_USE_DRAW_DMA2D
+
+#include "../lv_draw_image_private.h"
+#include "../lv_image_decoder_private.h"
+#include "../../misc/lv_area_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void lv_draw_dma2d_opaque_image_core(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                            const lv_image_decoder_dsc_t * decoder_dsc, lv_draw_image_sup_t * sup,
+                                            const lv_area_t * img_coords, const lv_area_t * clipped_img_area);
+
+static void lv_draw_dma2d_image_core(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                     const lv_image_decoder_dsc_t * decoder_dsc, lv_draw_image_sup_t * sup,
+                                     const lv_area_t * img_coords, const lv_area_t * clipped_img_area);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_dma2d_opaque_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                const lv_area_t * coords)
+{
+    if(!draw_dsc->tile) {
+        lv_draw_image_normal_helper(t, draw_dsc, coords, lv_draw_dma2d_opaque_image_core);
+    }
+    else {
+        lv_draw_image_tiled_helper(t, draw_dsc, coords, lv_draw_dma2d_opaque_image_core);
+    }
+}
+
+void lv_draw_dma2d_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                         const lv_area_t * coords)
+{
+    if(!draw_dsc->tile) {
+        lv_draw_image_normal_helper(t, draw_dsc, coords, lv_draw_dma2d_image_core);
+    }
+    else {
+        lv_draw_image_tiled_helper(t, draw_dsc, coords, lv_draw_dma2d_image_core);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_draw_dma2d_opaque_image_core(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                            const lv_image_decoder_dsc_t * decoder_dsc, lv_draw_image_sup_t * sup,
+                                            const lv_area_t * img_coords, const lv_area_t * clipped_img_area)
+{
+    LV_UNUSED(sup);
+    LV_UNUSED(img_coords);
+
+    lv_layer_t * layer = t->target_layer;
+
+    void * dest_first_pixel = lv_draw_layer_go_to_xy(layer,
+                                                     clipped_img_area->x1 - layer->buf_area.x1,
+                                                     clipped_img_area->y1 - layer->buf_area.y1);
+    int32_t dest_stride = lv_draw_buf_width_to_stride(lv_area_get_width(&layer->buf_area), layer->color_format);
+
+    int32_t w = lv_area_get_width(clipped_img_area);
+    int32_t h = lv_area_get_height(clipped_img_area);
+
+    lv_color_format_t output_cf = layer->color_format;
+    uint32_t output_cf_size = lv_color_format_get_size(output_cf);
+    lv_draw_dma2d_output_cf_t output_cf_dma2d = lv_draw_dma2d_cf_to_dma2d_output_cf(output_cf);
+
+    const lv_draw_buf_t * decoded = decoder_dsc->decoded;
+    const uint8_t * src_buf = decoded->data;
+    uint32_t image_stride = decoded->header.stride;
+    lv_color_format_t image_cf = decoded->header.cf;
+    lv_draw_dma2d_fgbg_cf_t image_cf_dma2d = (lv_draw_dma2d_fgbg_cf_t) lv_draw_dma2d_cf_to_dma2d_output_cf(image_cf);
+    uint32_t image_cf_size = LV_COLOR_FORMAT_GET_SIZE(image_cf);
+    if(image_stride == 0) image_stride = image_cf_size * decoded->header.w;
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t dest_area = {
+        .first_byte = dest_first_pixel,
+        .width_bytes = w * output_cf_size,
+        .height = h,
+        .stride = dest_stride
+    };
+    lv_draw_dma2d_unit_t * u = (lv_draw_dma2d_unit_t *) t->draw_unit;
+    lv_memcpy(&u->writing_area, &dest_area, sizeof(lv_draw_dma2d_cache_area_t));
+    if(lv_color_format_has_alpha(image_cf)) {
+        /* make sure the background area DMA2D is blending is up-to-date in main memory */
+        lv_draw_dma2d_clean_cache(&dest_area);
+    }
+#endif
+
+    const void * image_first_byte = src_buf
+                                    + (image_stride * (clipped_img_area->y1 - draw_dsc->image_area.y1))
+                                    + (image_cf_size * (clipped_img_area->x1 - draw_dsc->image_area.x1));
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t src_area = {
+        .first_byte = image_first_byte,
+        .width_bytes = w * image_cf_size,
+        .height = h,
+        .stride = image_stride
+    };
+    /* make sure the image area is up-to-date in main memory for DMA2D */
+    lv_draw_dma2d_clean_cache(&src_area);
+#endif
+
+    uint32_t output_offset = (dest_stride / output_cf_size) - w;
+    lv_draw_dma2d_configuration_t conf = {
+        .mode = LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_PFC,
+        .w = w,
+        .h = h,
+
+        .output_address = dest_first_pixel,
+        .output_offset = output_offset,
+        .output_cf = output_cf_dma2d,
+
+        .fg_address = image_first_byte,
+        .fg_offset = (image_stride / image_cf_size) - w,
+        .fg_cf = image_cf_dma2d
+    };
+
+    /* only process the background if the image might be transparent */
+    if(lv_color_format_has_alpha(image_cf)) {
+        conf.mode = LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING;
+
+        conf.bg_address = dest_first_pixel;
+        conf.bg_offset = output_offset;
+        conf.bg_cf = output_cf_dma2d;
+    }
+
+    /* Alpha channel should be treated as 0xFF if the cf is XRGB */
+    if(image_cf == LV_COLOR_FORMAT_XRGB8888) {
+        conf.fg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL;
+        conf.fg_alpha = 0xff;
+    }
+    if(output_cf == LV_COLOR_FORMAT_XRGB8888) {
+        conf.bg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL;
+        conf.bg_alpha = 0xff;
+    }
+
+    lv_draw_dma2d_configure_and_start_transfer(&conf);
+}
+
+static void lv_draw_dma2d_image_core(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                     const lv_image_decoder_dsc_t * decoder_dsc, lv_draw_image_sup_t * sup,
+                                     const lv_area_t * img_coords, const lv_area_t * clipped_img_area)
+{
+    LV_UNUSED(sup);
+    LV_UNUSED(img_coords);
+
+    lv_layer_t * layer = t->target_layer;
+
+    void * dest_first_pixel = lv_draw_layer_go_to_xy(layer,
+                                                     clipped_img_area->x1 - layer->buf_area.x1,
+                                                     clipped_img_area->y1 - layer->buf_area.y1);
+    int32_t dest_stride = lv_draw_buf_width_to_stride(lv_area_get_width(&layer->buf_area), layer->color_format);
+
+    int32_t w = lv_area_get_width(clipped_img_area);
+    int32_t h = lv_area_get_height(clipped_img_area);
+
+    lv_color_format_t output_cf = layer->color_format;
+    uint32_t output_cf_size = lv_color_format_get_size(output_cf);
+    lv_draw_dma2d_output_cf_t output_cf_dma2d = lv_draw_dma2d_cf_to_dma2d_output_cf(output_cf);
+
+    const lv_draw_buf_t * decoded = decoder_dsc->decoded;
+    const uint8_t * src_buf = decoded->data;
+    uint32_t image_stride = decoded->header.stride;
+    lv_color_format_t image_cf = decoded->header.cf;
+    lv_opa_t opa = draw_dsc->opa;
+    lv_draw_dma2d_fgbg_cf_t image_cf_dma2d = (lv_draw_dma2d_fgbg_cf_t) lv_draw_dma2d_cf_to_dma2d_output_cf(image_cf);
+    uint32_t image_cf_size = LV_COLOR_FORMAT_GET_SIZE(image_cf);
+    if(image_stride == 0) image_stride = image_cf_size * decoded->header.w;
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t dest_area = {
+        .first_byte = dest_first_pixel,
+        .width_bytes = w * output_cf_size,
+        .height = h,
+        .stride = dest_stride
+    };
+    lv_draw_dma2d_unit_t * u = (lv_draw_dma2d_unit_t *) t->draw_unit;
+    lv_memcpy(&u->writing_area, &dest_area, sizeof(lv_draw_dma2d_cache_area_t));
+    /* make sure the background area DMA2D is blending is up-to-date in main memory */
+    lv_draw_dma2d_clean_cache(&dest_area);
+#endif
+
+    const void * image_first_byte = src_buf
+                                    + (image_stride * (clipped_img_area->y1 - draw_dsc->image_area.y1))
+                                    + (image_cf_size * (clipped_img_area->x1 - draw_dsc->image_area.x1));
+
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t src_area = {
+        .first_byte = image_first_byte,
+        .width_bytes = w * image_cf_size,
+        .height = h,
+        .stride = image_stride
+    };
+    /* make sure the image area is up-to-date in main memory for DMA2D */
+    lv_draw_dma2d_clean_cache(&src_area);
+#endif
+
+    uint32_t output_offset = (dest_stride / output_cf_size) - w;
+    lv_draw_dma2d_configuration_t conf = {
+        .mode = LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING,
+        .w = w,
+        .h = h,
+
+        .output_address = dest_first_pixel,
+        .output_offset = output_offset,
+        .output_cf = output_cf_dma2d,
+
+        .fg_address = image_first_byte,
+        .fg_offset = (image_stride / image_cf_size) - w,
+        .fg_cf = image_cf_dma2d,
+        .fg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_MULTIPLY_IMAGE_ALPHA_CHANNEL,
+        .fg_alpha = opa,
+
+        .bg_address = dest_first_pixel,
+        .bg_offset = output_offset,
+        .bg_cf = output_cf_dma2d,
+    };
+
+    /* Alpha channel should be treated as 0xFF if the cf is XRGB */
+    if(image_cf == LV_COLOR_FORMAT_XRGB8888) {
+        conf.fg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL;
+    }
+    if(output_cf == LV_COLOR_FORMAT_XRGB8888) {
+        conf.bg_alpha_mode = LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL;
+        conf.bg_alpha = 0xff;
+    }
+
+    lv_draw_dma2d_configure_and_start_transfer(&conf);
+}
+
+#endif /*LV_USE_DRAW_DMA2D*/

components/easylvgl/lvgl9/src/draw/dma2d/lv_draw_dma2d_private.h

@@ -0,0 +1,155 @@
+/**
+ * @file lv_draw_dma2d_private.h
+ *
+ */
+
+#ifndef LV_DRAW_DMA2D_PRIVATE_H
+#define LV_DRAW_DMA2D_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_dma2d.h"
+#if LV_USE_DRAW_DMA2D
+
+#include "../lv_draw_private.h"
+#include "../sw/lv_draw_sw.h"
+#include LV_DRAW_DMA2D_HAL_INCLUDE
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#if LV_USE_DRAW_DMA2D_INTERRUPT && LV_USE_OS
+#define LV_DRAW_DMA2D_ASYNC 1
+#else
+#define LV_DRAW_DMA2D_ASYNC 0
+#endif
+
+#if defined(__CORTEX_M) && ((__CORTEX_M == 7) || (__CORTEX_M == 55))
+#define LV_DRAW_DMA2D_CACHE 1
+#else
+#define LV_DRAW_DMA2D_CACHE 0
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_DRAW_DMA2D_OUTPUT_CF_ARGB8888 = 0,
+    LV_DRAW_DMA2D_OUTPUT_CF_RGB888,
+    LV_DRAW_DMA2D_OUTPUT_CF_RGB565,
+    LV_DRAW_DMA2D_OUTPUT_CF_ARGB1555,
+    LV_DRAW_DMA2D_OUTPUT_CF_ARGB4444
+} lv_draw_dma2d_output_cf_t;
+
+typedef enum {
+    LV_DRAW_DMA2D_FGBG_CF_ARGB8888 = 0,
+    LV_DRAW_DMA2D_FGBG_CF_RGB888,
+    LV_DRAW_DMA2D_FGBG_CF_RGB565,
+    LV_DRAW_DMA2D_FGBG_CF_ARGB1555,
+    LV_DRAW_DMA2D_FGBG_CF_ARGB4444,
+    LV_DRAW_DMA2D_FGBG_CF_L8,
+    LV_DRAW_DMA2D_FGBG_CF_AL44,
+    LV_DRAW_DMA2D_FGBG_CF_AL88,
+    LV_DRAW_DMA2D_FGBG_CF_L4,
+    LV_DRAW_DMA2D_FGBG_CF_A8,
+    LV_DRAW_DMA2D_FGBG_CF_A4,
+    LV_DRAW_DMA2D_FGBG_CF_YCBCR
+} lv_draw_dma2d_fgbg_cf_t;
+
+typedef enum {
+    LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY = 0,
+    LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_PFC,
+    LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING,
+    LV_DRAW_DMA2D_MODE_REGISTER_TO_MEMORY,
+    LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING_AND_FIXED_COLOR_FG,
+    LV_DRAW_DMA2D_MODE_MEMORY_TO_MEMORY_WITH_BLENDING_AND_FIXED_COLOR_BG
+} lv_draw_dma2d_mode_t;
+
+typedef enum {
+    LV_DRAW_DMA2D_ALPHA_MODE_NO_MODIFY_IMAGE_ALPHA_CHANNEL = 0,
+    LV_DRAW_DMA2D_ALPHA_MODE_REPLACE_ALPHA_CHANNEL,
+    LV_DRAW_DMA2D_ALPHA_MODE_MULTIPLY_IMAGE_ALPHA_CHANNEL
+} lv_draw_dma2d_alpha_mode_t;
+
+typedef struct {
+    lv_draw_dma2d_mode_t mode;
+    uint32_t w;
+    uint32_t h;
+
+    void * output_address;
+    uint32_t output_offset;
+    lv_draw_dma2d_output_cf_t output_cf;
+
+    uint32_t reg_to_mem_mode_color;
+
+    const void * fg_address;
+    uint32_t fg_offset;
+    lv_draw_dma2d_fgbg_cf_t fg_cf;
+    uint32_t fg_color;
+    uint32_t fg_alpha_mode;
+    uint32_t fg_alpha;
+
+    const void * bg_address;
+    uint32_t bg_offset;
+    lv_draw_dma2d_fgbg_cf_t bg_cf;
+    uint32_t bg_color;
+    uint32_t bg_alpha_mode;
+    uint32_t bg_alpha;
+
+} lv_draw_dma2d_configuration_t;
+
+typedef struct {
+    const void * first_byte;
+    uint32_t width_bytes;
+    uint32_t height;
+    uint32_t stride;
+} lv_draw_dma2d_cache_area_t;
+
+typedef struct {
+    lv_draw_unit_t base_unit;
+    lv_draw_task_t * volatile task_act;
+#if LV_DRAW_DMA2D_CACHE
+    lv_draw_dma2d_cache_area_t writing_area;
+#endif
+#if LV_DRAW_DMA2D_ASYNC
+    lv_thread_sync_t interrupt_signal;
+#endif
+} lv_draw_dma2d_unit_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_dma2d_opaque_fill(lv_draw_task_t * t, void * first_pixel, int32_t w, int32_t h, int32_t stride);
+void lv_draw_dma2d_fill(lv_draw_task_t * t, void * first_pixel, int32_t w, int32_t h, int32_t stride);
+void lv_draw_dma2d_opaque_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                const lv_area_t * coords);
+void lv_draw_dma2d_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                         const lv_area_t * coords);
+lv_draw_dma2d_output_cf_t lv_draw_dma2d_cf_to_dma2d_output_cf(lv_color_format_t cf);
+uint32_t lv_draw_dma2d_color_to_dma2d_color(lv_draw_dma2d_output_cf_t cf, lv_color_t color);
+void lv_draw_dma2d_configure_and_start_transfer(const lv_draw_dma2d_configuration_t * conf);
+#if LV_DRAW_DMA2D_CACHE
+void lv_draw_dma2d_invalidate_cache(const lv_draw_dma2d_cache_area_t * mem_area);
+void lv_draw_dma2d_clean_cache(const lv_draw_dma2d_cache_area_t * mem_area);
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_DRAW_DMA2D*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_DMA2D_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa.c

@@ -0,0 +1,255 @@
+/**
+ * @file lv_draw_ppa.c
+ *
+ */
+
+/*********************
+*      INCLUDES
+*********************/
+
+#include "lv_draw_ppa_private.h"
+#include "lv_draw_ppa.h"
+
+#if LV_USE_PPA
+
+/*********************
+*      DEFINES
+*********************/
+
+#define DRAW_UNIT_ID_PPA         80
+#define DRAW_UNIT_PPA_PREF_SCORE 70
+
+/**********************
+*  STATIC PROTOTYPES
+**********************/
+
+static int32_t ppa_evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * task);
+static int32_t ppa_dispatch(lv_draw_unit_t * draw_unit, lv_layer_t * layer);
+static int32_t ppa_delete(lv_draw_unit_t * draw_unit);
+static void  ppa_execute_drawing(lv_draw_ppa_unit_t * u);
+static bool ppa_isr(ppa_client_handle_t ppa_client, ppa_event_data_t * event_data, void * user_data);
+
+#if LV_PPA_NONBLOCKING_OPS
+    static void ppa_thread(void * arg);
+#endif
+
+static bool g_ppa_complete = true;
+
+/**********************
+*   GLOBAL FUNCTIONS
+**********************/
+
+void lv_draw_ppa_init(void)
+{
+    esp_err_t res;
+    ppa_client_config_t cfg = {0};
+    ppa_event_callbacks_t ppa_cbs = {
+        .on_trans_done = ppa_isr,
+
+    };
+
+    /* Create draw unit */
+    lv_draw_buf_ppa_init_handlers();
+    lv_draw_ppa_unit_t * draw_ppa_unit = lv_draw_create_unit(sizeof(lv_draw_ppa_unit_t));
+    draw_ppa_unit->base_unit.evaluate_cb = ppa_evaluate;
+    draw_ppa_unit->base_unit.dispatch_cb  = ppa_dispatch;
+    draw_ppa_unit->base_unit.delete_cb    = ppa_delete;
+    draw_ppa_unit->base_unit.name         = "ESP_PPA";
+
+    /* Register SRM client */
+    cfg.oper_type = PPA_OPERATION_SRM;
+    cfg.max_pending_trans_num = 8;
+    cfg.data_burst_length = PPA_DATA_BURST_LENGTH_128;
+
+    res = ppa_register_client(&cfg, &draw_ppa_unit->srm_client);
+    LV_ASSERT(res == ESP_OK);
+
+    /* Register Fill client */
+    cfg.oper_type = PPA_OPERATION_FILL;
+    cfg.data_burst_length = PPA_DATA_BURST_LENGTH_128;
+    res = ppa_register_client(&cfg, &draw_ppa_unit->fill_client);
+    LV_ASSERT(res == ESP_OK);
+
+    /* Register Blend client */
+    cfg.oper_type = PPA_OPERATION_BLEND;
+    cfg.data_burst_length = PPA_DATA_BURST_LENGTH_32;
+
+    res = ppa_register_client(&cfg, &draw_ppa_unit->blend_client);
+    LV_ASSERT(res == ESP_OK);
+
+    ppa_client_register_event_callbacks(draw_ppa_unit->srm_client, &ppa_cbs);
+    ppa_client_register_event_callbacks(draw_ppa_unit->fill_client, &ppa_cbs);
+    ppa_client_register_event_callbacks(draw_ppa_unit->blend_client, &ppa_cbs);
+
+#if LV_PPA_NONBLOCKING_OPS
+    lv_result_t lv_res = lv_thread_init(&draw_ppa_unit->thread, "ppa_thread", LV_DRAW_THREAD_PRIO, ppa_thread, 8192,
+                                        draw_ppa_unit);
+    LV_ASSERT(lv_res == LV_RESULT_OK);
+#endif
+
+}
+
+void lv_draw_ppa_deinit(void)
+{
+    /* No global deinit required */
+}
+
+/**********************
+*   STATIC FUNCTIONS
+**********************/
+
+static bool ppa_isr(ppa_client_handle_t ppa_client, ppa_event_data_t * event_data, void * user_data)
+{
+    g_ppa_complete = true;
+
+#if LV_PPA_NONBLOCKING_OPS
+    lv_draw_ppa_unit_t * u = (lv_draw_ppa_unit_t *)user_data;
+    lv_thread_sync_signal_isr(&u->interrupt_signal);
+#endif
+
+    return false;
+}
+
+static int32_t ppa_evaluate(lv_draw_unit_t * u, lv_draw_task_t * t)
+{
+    LV_UNUSED(u);
+    const lv_draw_dsc_base_t * base = (lv_draw_dsc_base_t *)t->draw_dsc;
+
+    if(!ppa_dest_cf_supported(base->layer->color_format)) return 0;
+
+    switch(t->type) {
+        case LV_DRAW_TASK_TYPE_FILL: {
+                const lv_draw_fill_dsc_t * dsc = (lv_draw_fill_dsc_t *)t->draw_dsc;
+                if((dsc->radius != 0 || dsc->grad.dir != LV_GRAD_DIR_NONE)) return 0;
+                if(dsc->opa <= (lv_opa_t)LV_OPA_MAX) return 0;
+
+                if(t->preference_score > DRAW_UNIT_PPA_PREF_SCORE) {
+                    t->preference_score = DRAW_UNIT_PPA_PREF_SCORE;
+                    t->preferred_draw_unit_id = DRAW_UNIT_ID_PPA;
+                }
+                return 1;
+            }
+
+#if LV_USE_PPA_IMG
+        case LV_DRAW_TASK_TYPE_IMAGE: {
+                lv_draw_image_dsc_t * dsc = t->draw_dsc;
+                if(!(dsc->header.cf < LV_COLOR_FORMAT_PROPRIETARY_START
+                     && dsc->clip_radius == 0
+                     && dsc->bitmap_mask_src == NULL
+                     && dsc->sup == NULL
+                     && dsc->tile == 0
+                     && dsc->blend_mode == LV_BLEND_MODE_NORMAL
+                     && dsc->recolor_opa <= LV_OPA_MIN
+                     && dsc->opa <= (lv_opa_t)LV_OPA_MAX
+                     && dsc->skew_y == 0
+                     && dsc->skew_x == 0
+                     && dsc->scale_x == 256
+                     && dsc->scale_y == 256
+                     && dsc->rotation == 0
+                     && lv_image_src_get_type(dsc->src) == LV_IMAGE_SRC_VARIABLE
+                     && (dsc->header.cf == LV_COLOR_FORMAT_RGB888
+                         || dsc->header.cf == LV_COLOR_FORMAT_RGB565)
+                     && (dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB888
+                         || dsc->base.layer->color_format == LV_COLOR_FORMAT_RGB565))) {
+                    return 0;
+                }
+
+                if(t->preference_score > DRAW_UNIT_PPA_PREF_SCORE) {
+                    t->preference_score = DRAW_UNIT_PPA_PREF_SCORE;
+                    t->preferred_draw_unit_id = DRAW_UNIT_ID_PPA;
+                }
+                return 1;
+            }
+#endif
+        default:
+            return 0;
+    }
+}
+
+static int32_t ppa_dispatch(lv_draw_unit_t * draw_unit, lv_layer_t * layer)
+{
+    lv_draw_ppa_unit_t * u = (lv_draw_ppa_unit_t *)draw_unit;
+    if(u->task_act) {
+        if(!g_ppa_complete) {
+            return LV_DRAW_UNIT_IDLE;
+        }
+        else {
+            u->task_act->state = LV_DRAW_TASK_STATE_FINISHED;
+            u->task_act = NULL;
+        }
+    }
+
+    lv_draw_task_t * t = lv_draw_get_available_task(layer, NULL, DRAW_UNIT_ID_PPA);
+    if(!t || t->preferred_draw_unit_id != DRAW_UNIT_ID_PPA) return LV_DRAW_UNIT_IDLE;
+    if(!lv_draw_layer_alloc_buf(layer)) return LV_DRAW_UNIT_IDLE;
+
+    t->state = LV_DRAW_TASK_STATE_IN_PROGRESS;
+    u->task_act = t;
+    u->task_act->draw_unit = draw_unit;
+
+    ppa_execute_drawing(u);
+
+#if !LV_PPA_NONBLOCKING_OPS
+    u->task_act->state = LV_DRAW_TASK_STATE_FINISHED;
+    u->task_act = NULL;
+    lv_draw_dispatch_request();
+#endif
+
+    return 1;
+}
+
+static int32_t ppa_delete(lv_draw_unit_t * draw_unit)
+{
+    lv_draw_ppa_unit_t * u = (lv_draw_ppa_unit_t *)draw_unit;
+    ppa_unregister_client(u->srm_client);
+    ppa_unregister_client(u->fill_client);
+    ppa_unregister_client(u->blend_client);
+    return 0;
+}
+
+static void ppa_execute_drawing(lv_draw_ppa_unit_t * u)
+{
+    lv_draw_task_t * t         = u->task_act;
+    lv_layer_t * layer         = t->target_layer;
+    lv_draw_buf_t * buf        = layer->draw_buf;
+    lv_area_t area;
+    lv_area_t draw_area;
+
+    if(!lv_area_intersect(&area, &t->area, &t->clip_area)) return;
+
+    lv_area_move(&draw_area, -layer->buf_area.x1, -layer->buf_area.y1);
+    lv_draw_buf_invalidate_cache(buf, &draw_area);
+
+    switch(t->type) {
+        case LV_DRAW_TASK_TYPE_FILL:
+            g_ppa_complete = false;
+            lv_draw_ppa_fill(t, (lv_draw_fill_dsc_t *)t->draw_dsc, &area);
+            break;
+        case LV_DRAW_TASK_TYPE_IMAGE:
+            g_ppa_complete = false;
+            lv_draw_ppa_img(t, (lv_draw_image_dsc_t *)t->draw_dsc, &area);
+            break;
+        default:
+            break;
+    }
+}
+
+#if LV_PPA_NONBLOCKING_OPS
+static void ppa_thread(void * arg)
+{
+    lv_draw_ppa_unit_t * u = arg;
+    lv_thread_sync_init(&u->interrupt_signal);
+
+    while(1) {
+        do {
+            lv_thread_sync_wait(&u->interrupt_signal);
+        } while(u->task_act != NULL);
+
+        u->task_act->state = LV_DRAW_TASK_STATE_FINISHED;
+        u->task_act = NULL;
+        lv_draw_dispatch_request();
+    }
+}
+#endif
+
+#endif /*LV_USE_PPA*/

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_draw_ppa.h
+ *
+ */
+
+#ifndef LV_DRAW_PPA_H
+#define LV_DRAW_PPA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../../lv_conf_internal.h"
+
+#if LV_USE_PPA
+
+#include "../../lv_draw_private.h"
+#include "../../../display/lv_display_private.h"
+#include "../../../misc/lv_area_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_ppa_init(void);
+void lv_draw_ppa_deinit(void);
+void lv_draw_buf_ppa_init_handlers(void);
+
+void lv_draw_ppa_fill(lv_draw_task_t * t, const lv_draw_fill_dsc_t * dsc,
+                      const lv_area_t * coords);
+
+void lv_draw_ppa_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
+                     const lv_area_t * coords);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_PPA */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* LV_DRAW_PPA_H */

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa_buf.c

@@ -0,0 +1,52 @@
+/**
+ * @file lv_draw_ppa_buf.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_ppa_private.h"
+#include "lv_draw_ppa.h"
+
+#if LV_USE_PPA
+#include LV_STDINT_INCLUDE
+#include "../../lv_draw_buf_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ *********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ *********************/
+static void invalidate_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area);
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ *********************/
+
+void lv_draw_buf_ppa_init_handlers(void)
+{
+    lv_draw_buf_handlers_t * handlers = lv_draw_buf_get_handlers();
+    lv_draw_buf_handlers_t * image_handlers = lv_draw_buf_get_image_handlers();
+
+    handlers->invalidate_cache_cb       = invalidate_cache;
+    image_handlers->invalidate_cache_cb = invalidate_cache;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ *********************/
+
+static void invalidate_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area)
+{
+    esp_cache_msync((void *)PPA_PTR_ALIGN_DOWN(draw_buf->data, CONFIG_CACHE_L1_CACHE_LINE_SIZE),
+                    PPA_ALIGN_DOWN(draw_buf->data_size, CONFIG_CACHE_L1_CACHE_LINE_SIZE),
+                    ESP_CACHE_MSYNC_FLAG_DIR_C2M | ESP_CACHE_MSYNC_FLAG_TYPE_DATA);
+}
+#endif /* LV_USE_PPA */

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa_fill.c

@@ -0,0 +1,48 @@
+/**
+ * @file lv_draw_ppa_fill.c
+ *
+ */
+
+#include "lv_draw_ppa_private.h"
+#include "lv_draw_ppa.h"
+
+#if LV_USE_PPA
+
+void lv_draw_ppa_fill(lv_draw_task_t * t, const lv_draw_fill_dsc_t * dsc,
+                      const lv_area_t * coords)
+{
+    lv_draw_ppa_unit_t * u = (lv_draw_ppa_unit_t *)t->draw_unit;
+    lv_draw_buf_t * draw_buf = t->target_layer->draw_buf;
+    int width  = lv_area_get_width(coords);
+    int height = lv_area_get_height(coords);
+
+    if(width <= 0 || height <= 0) {
+        LV_LOG_WARN("Invalid draw area for filling!");
+        return;
+    }
+
+    ppa_fill_oper_config_t cfg = {
+        .fill_argb_color.val = lv_color_to_u32(dsc->color),
+        .fill_block_w    = width,
+        .fill_block_h    = height,
+        .out = {
+            .buffer         = draw_buf->data,
+            .buffer_size    = draw_buf->data_size,
+            .pic_w          = width,
+            .pic_h          = height,
+            .block_offset_x = 0,
+            .block_offset_y = 0,
+            .fill_cm        = lv_color_format_to_ppa_fill(draw_buf->header.cf),
+        },
+
+        .mode            = PPA_TRANS_MODE_NON_BLOCKING,
+        .user_data       = u,
+    };
+
+    esp_err_t ret = ppa_do_fill(u->fill_client, &cfg);
+    if(ret != ESP_OK) {
+        LV_LOG_ERROR("PPA fill failed: %d", ret);
+    }
+}
+
+#endif /* LV_USE_PPA */

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa_img.c

@@ -0,0 +1,77 @@
+/**
+ * @file lv_draw_ppa_img.c
+ *
+ */
+
+#include "lv_draw_ppa_private.h"
+#include "lv_draw_ppa.h"
+
+#if LV_USE_PPA
+
+void lv_draw_ppa_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
+                     const lv_area_t * coords)
+{
+    if(dsc->opa <= (lv_opa_t)LV_OPA_MIN) {
+        return;
+    }
+
+    lv_draw_ppa_unit_t * u = (lv_draw_ppa_unit_t *)t->draw_unit;
+    lv_draw_buf_t * draw_buf = t->target_layer->draw_buf;
+    const lv_image_dsc_t * img_dsc = dsc->src;
+    int width  = lv_area_get_width(coords);
+    int height = lv_area_get_height(coords);
+
+    ppa_blend_oper_config_t cfg = {
+        .in_bg = {
+            .buffer          = (void *)draw_buf->data,
+            .pic_w           = draw_buf->header.w,
+            .pic_h           = draw_buf->header.h,
+            .block_w         = width,
+            .block_h         = height,
+            .block_offset_x  = 0,
+            .block_offset_y  = 0,
+            .blend_cm        = lv_color_format_to_ppa_blend(draw_buf->header.cf),
+        },
+        .bg_rgb_swap           = false,
+        .bg_byte_swap          = false,
+        .bg_alpha_update_mode  = PPA_ALPHA_NO_CHANGE,
+        .bg_alpha_fix_val      = 0,
+        .bg_ck_en              = false,
+
+        .in_fg = {
+            .buffer          = (void *)img_dsc->data,
+            .pic_w           = width,
+            .pic_h           = height,
+            .block_w         = width,
+            .block_h         = height,
+            .block_offset_x  = 0,
+            .block_offset_y  = 0,
+            .blend_cm        = lv_color_format_to_ppa_blend(dsc->header.cf),
+        },
+        .fg_rgb_swap           = false,
+        .fg_byte_swap          = false,
+        .fg_alpha_update_mode = PPA_ALPHA_NO_CHANGE,
+        .fg_alpha_fix_val      = 0xFF,
+        .fg_ck_en              = false,
+
+        .out = {
+            .buffer          = draw_buf->data,
+            .buffer_size     = PPA_ALIGN_UP(draw_buf->data_size, CONFIG_CACHE_L1_CACHE_LINE_SIZE),
+            .pic_w           = draw_buf->header.w,
+            .pic_h           = draw_buf->header.h,
+            .block_offset_x  = 0,
+            .block_offset_y  = 0,
+            .blend_cm        = lv_color_format_to_ppa_blend(draw_buf->header.cf),
+        },
+
+        .mode            = PPA_TRANS_MODE_NON_BLOCKING,
+        .user_data       = u,
+    };
+
+    esp_err_t ret = ppa_do_blend(u->blend_client, &cfg);
+    if(ret != ESP_OK) {
+        LV_LOG_WARN("PPA draw_img blend failed: %d", ret);
+    }
+}
+
+#endif /* LV_USE_PPA */

components/easylvgl/lvgl9/src/draw/espressif/ppa/lv_draw_ppa_private.h

@@ -0,0 +1,185 @@
+/**
+ * @file lv_draw_ppa_private.h
+ *
+ */
+
+#ifndef LV_DRAW_PPA_PRIVATE_H
+#define LV_DRAW_PPA_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+*      INCLUDES
+*********************/
+#include "../../../lv_conf_internal.h"
+
+#if LV_USE_PPA
+#if LV_PPA_NONBLOCKING_OPS
+#error "PPA draw in nonblocking is experimental and not supported yet, please make it to 0!"
+#endif
+
+#ifndef LV_PPA_NONBLOCKING_OPS
+#define LV_PPA_NONBLOCKING_OPS 0
+#endif
+
+#include LV_STDDEF_INCLUDE
+#include LV_STDBOOL_INCLUDE
+#include LV_STDINT_INCLUDE
+
+#include "../../../misc/lv_color.h"
+#include "../../../misc/lv_log.h"
+#include "../../lv_draw_private.h"
+#include "../../../display/lv_display_private.h"
+#include "../../../misc/lv_area_private.h"
+
+/* The ppa driver depends heavily on the esp-idf headers*/
+#include "sdkconfig.h"
+
+#if CONFIG_LV_ATTRIBUTE_MEM_ALIGN_SIZE != CONFIG_CACHE_L1_CACHE_LINE_SIZE || CONFIG_LV_DRAW_BUF_ALIGN != CONFIG_CACHE_L1_CACHE_LINE_SIZE
+#error "For using PPA buffers need to be aligned to 64-byte boundary!"
+#endif
+
+
+#ifndef CONFIG_SOC_PPA_SUPPORTED
+#error "This SoC does not support PPA"
+#endif
+
+#include "driver/ppa.h"
+#include "esp_heap_caps.h"
+#include "esp_err.h"
+#include "hal/color_hal.h"
+#include "esp_cache.h"
+#include "esp_log.h"
+/*********************
+*      DEFINES
+*********************/
+
+/**********************
+*      TYPEDEFS
+**********************/
+typedef struct lv_draw_ppa_unit {
+    lv_draw_unit_t base_unit;
+    lv_draw_task_t * task_act;
+    ppa_client_handle_t srm_client;
+    ppa_client_handle_t fill_client;
+    ppa_client_handle_t blend_client;
+    uint8_t * buf;
+#if LV_PPA_NONBLOCKING_OPS
+    lv_thread_t thread;
+    lv_thread_sync_t interrupt_signal;
+#endif
+} lv_draw_ppa_unit_t;
+
+/**********************
+*  STATIC PROTOTYPES
+**********************/
+
+/**********************
+* GLOBAL PROTOTYPES
+**********************/
+
+/**********************
+*      MACROS
+**********************/
+
+/**********************
+*   STATIC FUNCTIONS
+**********************/
+
+static inline bool ppa_src_cf_supported(lv_color_format_t cf)
+{
+    bool is_cf_supported = false;
+
+    switch(cf) {
+        case LV_COLOR_FORMAT_RGB565:
+        case LV_COLOR_FORMAT_ARGB8888:
+        case LV_COLOR_FORMAT_XRGB8888:
+            is_cf_supported = true;
+            break;
+        default:
+            break;
+    }
+
+    return is_cf_supported;
+}
+
+static inline bool ppa_dest_cf_supported(lv_color_format_t cf)
+{
+    bool is_cf_supported = false;
+
+    switch(cf) {
+        case LV_COLOR_FORMAT_RGB565:
+        case LV_COLOR_FORMAT_RGB888:
+        case LV_COLOR_FORMAT_ARGB8888:
+        case LV_COLOR_FORMAT_XRGB8888:
+            is_cf_supported = true;
+            break;
+        default:
+            break;
+    }
+
+    return is_cf_supported;
+}
+
+static inline ppa_fill_color_mode_t lv_color_format_to_ppa_fill(lv_color_format_t lv_fmt)
+{
+    switch(lv_fmt) {
+        case LV_COLOR_FORMAT_RGB565:
+            return PPA_FILL_COLOR_MODE_RGB565;
+        case LV_COLOR_FORMAT_RGB888:
+            return PPA_FILL_COLOR_MODE_RGB888;
+        case LV_COLOR_FORMAT_ARGB8888:
+        case LV_COLOR_FORMAT_XRGB8888:
+            return PPA_FILL_COLOR_MODE_ARGB8888;
+        default:
+            return PPA_FILL_COLOR_MODE_RGB565;
+    }
+}
+
+static inline ppa_blend_color_mode_t lv_color_format_to_ppa_blend(lv_color_format_t lv_fmt)
+{
+    switch(lv_fmt) {
+        case LV_COLOR_FORMAT_RGB565:
+            return PPA_BLEND_COLOR_MODE_RGB565;
+        case LV_COLOR_FORMAT_RGB888:
+            return PPA_BLEND_COLOR_MODE_RGB888;
+        case LV_COLOR_FORMAT_ARGB8888:
+        case LV_COLOR_FORMAT_XRGB8888:
+            return PPA_BLEND_COLOR_MODE_ARGB8888;
+        default:
+            return PPA_BLEND_COLOR_MODE_RGB565;
+    }
+}
+
+static inline ppa_srm_color_mode_t lv_color_format_to_ppa_srm(lv_color_format_t lv_fmt)
+{
+    switch(lv_fmt) {
+        case LV_COLOR_FORMAT_RGB565:
+            return PPA_SRM_COLOR_MODE_RGB565;
+        case LV_COLOR_FORMAT_RGB888:
+            return PPA_SRM_COLOR_MODE_RGB888;
+        case LV_COLOR_FORMAT_XRGB8888:
+        case LV_COLOR_FORMAT_ARGB8888:
+            return PPA_SRM_COLOR_MODE_ARGB8888;
+        default:
+            return PPA_SRM_COLOR_MODE_RGB565;
+    }
+}
+
+#define PPA_ALIGN_UP(x, align)  ((((x) + (align) - 1) / (align)) * (align))
+#define PPA_PTR_ALIGN_UP(p, align) \
+    ((void*)(((uintptr_t)(p) + (uintptr_t)((align) - 1)) & ~(uintptr_t)((align) - 1)))
+
+#define PPA_ALIGN_DOWN(x, align)  ((((x) - (align) - 1) / (align)) * (align))
+#define PPA_PTR_ALIGN_DOWN(p, align) \
+    ((void*)(((uintptr_t)(p) - (uintptr_t)((align) - 1)) & ~(uintptr_t)((align) - 1)))
+
+#endif /* LV_USE_PPA */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* LV_DRAW_PPA_PRIVATE_H */

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve.c

@@ -0,0 +1,164 @@
+/**
+ * @file lv_draw_eve.c
+ *
+ */
+
+/*  Created on: 3 dic 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+
+#include "../../core/lv_refr.h"
+#include "../../display/lv_display_private.h"
+#include "../../stdlib/lv_string.h"
+#include "lv_draw_eve_ram_g.h"
+#include "lv_draw_eve.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define DRAW_UNIT_ID_EVE 9
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void eve_execute_drawing(lv_draw_eve_unit_t * u);
+
+static int32_t eve_dispatch(lv_draw_unit_t * draw_unit, lv_layer_t * layer);
+
+static int32_t eve_evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * task);
+
+static void disp_delete_cb(lv_event_t * e);
+
+/**********************
+ *  GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_init(void)
+{
+    lv_draw_eve_unit_t * draw_eve_unit = lv_draw_create_unit(sizeof(lv_draw_eve_unit_t));
+    draw_eve_unit->base_unit.dispatch_cb = eve_dispatch;
+    draw_eve_unit->base_unit.evaluate_cb = eve_evaluate;
+
+    lv_draw_eve_unit_g = draw_eve_unit;
+}
+
+void lv_draw_eve_set_display_data(lv_display_t * disp, const lv_draw_eve_parameters_t * params,
+                                  lv_draw_eve_operation_cb_t op_cb)
+{
+    if(lv_draw_eve_unit_g == NULL) {
+        LV_LOG_WARN("lv_draw_eve is not initialized.");
+        return;
+    }
+
+    lv_draw_eve_unit_g->disp = disp;
+    lv_draw_eve_unit_g->params = *params; /* make a copy */
+    lv_draw_eve_unit_g->op_cb = op_cb;
+
+    lv_display_add_event_cb(disp, disp_delete_cb, LV_EVENT_DELETE, NULL);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static int32_t eve_dispatch(lv_draw_unit_t * draw_unit, lv_layer_t * layer)
+{
+    lv_draw_eve_unit_t * draw_eve_unit = (lv_draw_eve_unit_t *) draw_unit;
+
+    lv_draw_task_t * t = NULL;
+    t = lv_draw_get_next_available_task(layer, NULL, DRAW_UNIT_ID_EVE);
+    if(t == NULL) return LV_DRAW_UNIT_IDLE;
+
+
+    t->state = LV_DRAW_TASK_STATE_IN_PROGRESS;
+    draw_eve_unit->task_act = t;
+
+    eve_execute_drawing(draw_eve_unit);
+
+    draw_eve_unit->task_act->state = LV_DRAW_TASK_STATE_FINISHED;
+    draw_eve_unit->task_act = NULL;
+
+    /*The draw unit is free now. Request a new dispatching as it can get a new task*/
+    lv_draw_dispatch_request();
+
+
+    return 1;
+}
+
+static int32_t eve_evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * task)
+{
+    LV_UNUSED(draw_unit);
+
+    if(((lv_draw_dsc_base_t *)task->draw_dsc)->user_data == NULL) {
+        task->preference_score = 0;
+        task->preferred_draw_unit_id = DRAW_UNIT_ID_EVE;
+    }
+    return 0;
+}
+
+static void eve_execute_drawing(lv_draw_eve_unit_t * u)
+{
+    lv_draw_task_t * t = u->task_act;
+
+    switch(t->type) {
+        case LV_DRAW_TASK_TYPE_LINE:
+            lv_draw_eve_line(t, t->draw_dsc);
+            break;
+        case LV_DRAW_TASK_TYPE_BORDER:
+            lv_draw_eve_border(t, t->draw_dsc, &t->area);
+            break;
+        case LV_DRAW_TASK_TYPE_FILL:
+            lv_draw_eve_fill(t, t->draw_dsc, &t->area);
+            break;
+        case LV_DRAW_TASK_TYPE_IMAGE:
+            lv_draw_eve_image(t, t->draw_dsc, &t->area);
+            break;
+        case LV_DRAW_TASK_TYPE_LABEL:
+            lv_draw_eve_label(t, t->draw_dsc, &t->area);
+            break;
+        case LV_DRAW_TASK_TYPE_ARC:
+            lv_draw_eve_arc(t, t->draw_dsc, &t->area);
+            break;
+        case LV_DRAW_TASK_TYPE_TRIANGLE:
+            lv_draw_eve_triangle(t, t->draw_dsc);
+            break;
+        default:
+            break;
+    }
+}
+
+static void disp_delete_cb(lv_event_t * e)
+{
+    lv_draw_eve_unit_g->disp = NULL;
+    lv_draw_eve_unit_g = NULL;
+}
+
+
+#endif /*LV_USE_DRAW_EVE*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_draw_eve.h
+ *
+ */
+
+/*  Created on: 3 dic 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+#ifndef LV_DRAW_EVE_H
+#define LV_DRAW_EVE_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_DRAW_EVE
+
+#include "lv_draw_eve_target.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_eve_init(void);
+
+void lv_draw_eve_set_display_data(lv_display_t * disp, const lv_draw_eve_parameters_t * params,
+                                  lv_draw_eve_operation_cb_t op_cb);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_DRAW_EVE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+
+#endif /* LV_DRAW_EVE_H */

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_arc.c

@@ -0,0 +1,325 @@
+/**
+ * @file lv_draw_eve_arc.c
+ *
+ */
+
+/*  Created on: 11 dic 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+
+#include "../lv_draw_arc.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ * STATIC PROTOTYPES
+ **********************/
+
+static void draw_eve_arc(lv_draw_task_t * t, const lv_draw_arc_dsc_t * dsc, const lv_area_t * coords);
+static bool is_same_quadrant(int16_t start_angle, int16_t end_angle) ;
+static void draw_rounded_end(lv_point_t center, int32_t radius, int32_t angle, int32_t width);
+static void lv_draw_eve_mask_angle(const lv_draw_arc_dsc_t * dsc, int32_t vertex_x, int32_t vertex_y,
+                                   int32_t start_angle, int32_t end_angle);
+static lv_eve_primitive_t get_mask_direction(int16_t angle);
+static int32_t chord_length(int16_t radius, int16_t angle_degrees);
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_arc(lv_draw_task_t * t, const lv_draw_arc_dsc_t * dsc, const lv_area_t * coords)
+{
+    draw_eve_arc(t, dsc, coords);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+
+static int32_t chord_length(int16_t radius, int16_t angle_degrees)
+{
+    angle_degrees %= 360;
+    if(angle_degrees < 0) angle_degrees += 360;
+    int32_t sin_value = lv_trigo_sin(angle_degrees / 2);
+    int64_t chord_length = 2 * radius * sin_value / 32768.0;
+    return (int32_t)chord_length ;
+}
+
+
+static lv_eve_primitive_t get_mask_direction(int16_t angle)
+{
+    if(angle >= 315 || angle <  45) {
+        return LV_EVE_PRIMITIVE_EDGE_STRIP_R;
+    }
+    if(angle >=  45 && angle < 135) {
+        return LV_EVE_PRIMITIVE_EDGE_STRIP_B;
+    }
+    if(angle >= 135 && angle < 225) {
+        return LV_EVE_PRIMITIVE_EDGE_STRIP_L;
+    }
+    if(angle >= 225 && angle < 315) {
+        return LV_EVE_PRIMITIVE_EDGE_STRIP_A;
+    }
+    return 0;
+}
+
+
+static void draw_rounded_end(lv_point_t center, int32_t radius, int32_t angle, int32_t width)
+{
+    int32_t rounded_y  = center.y + ((lv_trigo_sin(angle) * radius) >> LV_TRIGO_SHIFT);
+    int32_t rounded_x  = center.x + ((lv_trigo_cos(angle) * radius) >> LV_TRIGO_SHIFT);
+    lv_eve_draw_circle_simple(rounded_x, rounded_y, width);
+}
+
+
+
+static bool is_same_quadrant(int16_t start_angle, int16_t end_angle)
+{
+    if(start_angle > end_angle) {
+        if((start_angle >= 0 && start_angle < 90) && (end_angle >= 0 && end_angle < 90)) {
+            return true;
+        }
+        else if((start_angle >= 90 && start_angle < 180) && (end_angle >= 90 && end_angle < 180)) {
+            return true;
+        }
+        else if((start_angle >= 180 && start_angle < 270) && (end_angle >= 180 && end_angle < 270)) {
+            return true;
+        }
+        else if((start_angle >= 270 && start_angle < 360) && (end_angle >= 270 && end_angle < 360)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}
+
+
+
+static void lv_draw_eve_mask_angle(const lv_draw_arc_dsc_t * dsc, int32_t vertex_x, int32_t vertex_y,
+                                   int32_t start_angle, int32_t end_angle)
+{
+
+    /*Constrain the input angles*/
+
+
+    if(start_angle < 0)
+        start_angle = 0;
+    else if(start_angle > 359)
+        start_angle = 359;
+
+    if(end_angle < 0)
+        end_angle = 0;
+    else if(end_angle > 359)
+        end_angle = 359;
+
+    LV_ASSERT_MSG(start_angle >= 0 && start_angle <= 360, "Unexpected start angle");
+
+    int32_t mid_angle_op;
+    int32_t angle_range;
+    int32_t mask_dir_start;
+    int32_t mask_dir_end;
+    lv_point_t start;
+    lv_point_t end;
+    lv_point_t angle_range_op;
+
+    if(end_angle > start_angle) {
+        angle_range = LV_ABS(end_angle - start_angle);
+    }
+    else {
+        angle_range = 360 - start_angle + end_angle;
+    }
+
+    mid_angle_op = (angle_range / 2) + start_angle + 180;
+    mid_angle_op = mid_angle_op % 360;
+
+    mask_dir_end = LV_ABS(((360 - angle_range) / 4) + end_angle);
+    mask_dir_start = LV_ABS(((360 - angle_range) / 4) + mid_angle_op);
+
+    mask_dir_start = mask_dir_start % 360;
+    mask_dir_end = mask_dir_end % 360;
+
+    start.y = (lv_trigo_sin(start_angle) >> 5) + vertex_y;
+    start.x = (lv_trigo_cos(start_angle) >> 5) + vertex_x;
+
+    end.y = (lv_trigo_sin(end_angle) >> 5) + vertex_y;
+    end.x = (lv_trigo_cos(end_angle) >> 5) + vertex_x;
+
+    angle_range_op.y = (lv_trigo_sin(mid_angle_op) >> 5) + vertex_y;
+    angle_range_op.x = (lv_trigo_cos(mid_angle_op) >> 5) + vertex_x;
+
+    if(angle_range <= 180) {
+        /* Two sides mask and 6 vertex points */
+
+        /* Masking end angle */
+        lv_eve_primitive_t edge = get_mask_direction(mask_dir_end);
+        lv_eve_primitive(edge); /* Side one */
+        lv_eve_vertex_2f(angle_range_op.x, angle_range_op.y);
+        lv_eve_vertex_2f(vertex_x, vertex_y);
+        lv_eve_vertex_2f(end.x, end.y);
+
+        /* Masking start angle */
+        edge = get_mask_direction(mask_dir_start);
+        lv_eve_primitive(edge); /* Side two */
+        lv_eve_vertex_2f(angle_range_op.x, angle_range_op.y);
+        lv_eve_vertex_2f(vertex_x, vertex_y);
+        lv_eve_vertex_2f(start.x, start.y);
+
+    }
+
+    else {
+
+        if(is_same_quadrant(start_angle,
+                            end_angle)) { /* "It is not an optimal implementation for the case where both angles (start and end) are in the same quadrant */
+            /* todo */
+            lv_point_t end_line_cntr;
+            lv_point_t start_line_cntr;
+
+            lv_point_t end_line_brd;
+            lv_point_t start_line_brd;
+
+            int16_t chord = chord_length(dsc->radius, 360 - angle_range);
+            int16_t w = ((chord / 4) < 1) ? 1 : chord / 4;
+            int16_t r_width = w;
+
+            end_line_brd.y = vertex_y + ((lv_trigo_sin(end_angle) * dsc->radius) >> LV_TRIGO_SHIFT);
+            end_line_brd.x = vertex_x + ((lv_trigo_cos(end_angle) * dsc->radius) >> LV_TRIGO_SHIFT);
+
+            start_line_brd.y = vertex_y + ((lv_trigo_sin(start_angle) * dsc->radius) >> LV_TRIGO_SHIFT);
+            start_line_brd.x = vertex_x + ((lv_trigo_cos(start_angle) * dsc->radius) >> LV_TRIGO_SHIFT);
+
+            lv_eve_draw_rect_simple(start_line_brd.x, start_line_brd.y, end_line_brd.x, end_line_brd.y, 0);
+
+            start_line_brd.y = start_line_brd.y + ((lv_trigo_sin(start_angle - 90) * r_width) >> LV_TRIGO_SHIFT);
+            start_line_brd.x = start_line_brd.x + ((lv_trigo_cos(start_angle - 90) * r_width) >> LV_TRIGO_SHIFT);
+
+            end_line_brd.y = end_line_brd.y + ((lv_trigo_sin(end_angle + 90) * r_width) >> LV_TRIGO_SHIFT);
+            end_line_brd.x = end_line_brd.x + ((lv_trigo_cos(end_angle + 90) * r_width) >> LV_TRIGO_SHIFT);
+
+            end_line_cntr.y = vertex_y + ((lv_trigo_sin(end_angle + 90) * r_width) >> LV_TRIGO_SHIFT);
+            end_line_cntr.x = vertex_x + ((lv_trigo_cos(end_angle + 90) * r_width) >> LV_TRIGO_SHIFT);
+
+            start_line_cntr.y = vertex_y + ((lv_trigo_sin(start_angle + 270) * r_width) >> LV_TRIGO_SHIFT);
+            start_line_cntr.x = vertex_x + ((lv_trigo_cos(start_angle + 270) * r_width) >> LV_TRIGO_SHIFT);
+
+            lv_eve_primitive(LV_EVE_PRIMITIVE_LINE_STRIP);
+            lv_eve_line_width(r_width * 16);
+            lv_eve_vertex_2f(start_line_cntr.x, start_line_cntr.y);
+            lv_eve_vertex_2f(start_line_brd.x, start_line_brd.y);
+            lv_eve_vertex_2f(end_line_brd.x, end_line_brd.y);
+            lv_eve_vertex_2f(end_line_cntr.x, end_line_cntr.y);
+
+        }
+        else { /* One side mask and 3 vertex points */
+            /* Masking end and start angles */
+            lv_eve_primitive_t edge = get_mask_direction(mid_angle_op);
+            lv_eve_primitive(edge);
+            lv_eve_vertex_2f(end.x, end.y);
+            lv_eve_vertex_2f(vertex_x, vertex_y);
+            lv_eve_vertex_2f(start.x, start.y);
+        }
+    }
+
+}
+
+
+
+static void draw_eve_arc(lv_draw_task_t * t, const lv_draw_arc_dsc_t * dsc, const lv_area_t * coords)
+{
+
+    if(dsc->opa <= LV_OPA_MIN)
+        return;
+    if(dsc->width == 0)
+        return;
+    if(dsc->start_angle == dsc->end_angle)
+        return;
+
+    lv_color_t color = dsc->color;
+    lv_opa_t opa = dsc->opa;
+    lv_point_t center = dsc->center;
+    int32_t width = dsc->width;
+    uint16_t radius_out = dsc->radius;
+    uint16_t radius_in = dsc->radius - dsc->width;
+    int32_t start_angle = (int32_t) dsc->start_angle;
+    int32_t end_angle = (int32_t) dsc->end_angle;
+
+    if(width > radius_out)
+        width = radius_out;
+
+    while(start_angle >= 360)
+        start_angle -= 360;
+    while(end_angle >= 360)
+        end_angle -= 360;
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+
+    lv_eve_save_context();
+
+    lv_eve_color(color);
+    lv_eve_color_opa(opa);
+
+    lv_eve_color_mask(0, 0, 0, 1);
+    lv_eve_stencil_func(EVE_ALWAYS, 0, 1);
+    lv_eve_stencil_op(EVE_REPLACE, EVE_REPLACE);
+    lv_eve_draw_circle_simple(center.x, center.y, radius_out); /* radius_out */
+
+    lv_eve_blend_func(EVE_ONE, EVE_ZERO);
+    lv_eve_draw_circle_simple(center.x, center.y, radius_in + 2); /* radius_in */
+
+    lv_eve_stencil_func(EVE_ALWAYS, 1, 1);
+    lv_eve_stencil_op(EVE_REPLACE, EVE_REPLACE);
+    lv_eve_blend_func(EVE_ZERO, EVE_ONE_MINUS_SRC_ALPHA);
+    lv_eve_color_opa(0XFF);
+
+    /* Start masking arc */
+
+    lv_draw_eve_mask_angle(dsc, center.x, center.y, start_angle, end_angle);
+
+    /* End masking arc */
+
+    lv_eve_draw_circle_simple(center.x, center.y, radius_in); /* radius_in */
+
+    lv_eve_color_mask(1, 1, 1, 1);
+    lv_eve_blend_func(EVE_DST_ALPHA, EVE_ONE_MINUS_DST_ALPHA);
+    lv_eve_draw_circle_simple(center.x, center.y, radius_in); /* radius_in */
+
+    lv_eve_stencil_func(EVE_NOTEQUAL, 1, 0XFF);
+    lv_eve_stencil_op(EVE_KEEP, EVE_KEEP);
+    lv_eve_blend_func(EVE_SRC_ALPHA, EVE_ONE_MINUS_SRC_ALPHA);
+
+    lv_eve_color_opa(opa);
+    lv_eve_draw_circle_simple(center.x, center.y, radius_out); /* radius_out */
+
+    if(dsc->rounded) {
+        lv_eve_stencil_func(EVE_EQUAL, 1, 0XFF);
+        if(opa < 255) {
+            lv_eve_stencil_op(EVE_ZERO, EVE_ZERO);
+        }
+
+        int32_t half_width = width / 2;
+        int32_t adjusted_radius = radius_out - half_width;
+        draw_rounded_end(center, adjusted_radius, end_angle, half_width);
+        draw_rounded_end(center, adjusted_radius, start_angle, half_width);
+    }
+
+    lv_eve_restore_context();
+}
+
+
+
+#endif /*LV_USE_DRAW_EVE*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_fill.c

@@ -0,0 +1,121 @@
+/**
+ * @file lv_draw_eve_fill.c
+ *
+ */
+
+/*  Created on: 27 mar 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+#include "lv_eve.h"
+
+
+/**********************
+ * STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_fill(lv_draw_task_t * t, const lv_draw_fill_dsc_t * dsc, const lv_area_t * coords)
+{
+
+    int32_t rad = dsc->radius;
+    int32_t bg_w = lv_area_get_width(coords);
+    int32_t bg_h = lv_area_get_height(coords);
+    int32_t real_radius = LV_MIN3(bg_w / 2, bg_h / 2, rad);
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+    lv_eve_save_context();
+
+    lv_eve_color(dsc->color);
+    lv_eve_color_opa(dsc->opa);
+
+    if(bg_w == bg_h && rad == LV_RADIUS_CIRCLE) {
+        lv_eve_draw_circle_simple(coords->x1 + (bg_w / 2), coords->y1 + (bg_h / 2), real_radius);
+    }
+    else {
+        lv_eve_draw_rect_simple(coords->x1, coords->y1, coords->x2, coords->y2, real_radius);
+    }
+
+    lv_eve_restore_context();
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+
+
+void lv_draw_eve_border(lv_draw_task_t * t, const lv_draw_border_dsc_t * dsc, const lv_area_t * coords)
+{
+
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->width == 0) return;
+    if(dsc->side == LV_BORDER_SIDE_NONE) return;
+
+    int32_t coords_w = lv_area_get_width(coords);
+    int32_t coords_h = lv_area_get_height(coords);
+    int32_t rout = dsc->radius;
+    int32_t short_side = LV_MIN(coords_w, coords_h);
+    if(rout > short_side >> 1) rout = short_side >> 1;
+
+    /*Get the inner area*/
+    lv_area_t area_inner;
+    lv_area_copy(&area_inner, coords);
+    area_inner.x1 += ((dsc->side & LV_BORDER_SIDE_LEFT) ? dsc->width : - (dsc->width));
+    area_inner.x2 -= ((dsc->side & LV_BORDER_SIDE_RIGHT) ? dsc->width : - (dsc->width));
+    area_inner.y1 += ((dsc->side & LV_BORDER_SIDE_TOP) ? dsc->width : - (dsc->width));
+    area_inner.y2 -= ((dsc->side & LV_BORDER_SIDE_BOTTOM) ? dsc->width : - (dsc->width));
+
+    int32_t rin = rout - dsc->width;
+    if(rin < 0) rin = 0;
+
+    lv_eve_save_context();
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+
+    lv_eve_color(dsc->color);
+    lv_eve_color_opa(dsc->opa);
+
+    lv_eve_color_mask(0, 0, 0, 1);
+    lv_eve_stencil_func(EVE_ALWAYS, 0, 1);
+    lv_eve_stencil_op(EVE_REPLACE, EVE_REPLACE);
+    lv_eve_draw_rect_simple(coords->x1, coords->y1, coords->x2, coords->y2, 0);
+
+    lv_eve_blend_func(EVE_ONE, EVE_ZERO);
+    lv_eve_draw_rect_simple(area_inner.x1 - 2, area_inner.y1 - 1, area_inner.x2 + 1, area_inner.y2 + 2, rin);
+
+    lv_eve_stencil_func(EVE_ALWAYS, 1, 1);
+    lv_eve_stencil_op(EVE_REPLACE, EVE_REPLACE);
+    lv_eve_blend_func(EVE_ZERO, EVE_ONE_MINUS_SRC_ALPHA);
+    lv_eve_color_opa(255);
+    lv_eve_draw_rect_simple(area_inner.x1, area_inner.y1, area_inner.x2, area_inner.y2, rin);
+
+    lv_eve_color_mask(1, 1, 1, 1);
+
+    if(dsc->side == LV_BORDER_SIDE_FULL) {
+        lv_eve_blend_func(EVE_DST_ALPHA, EVE_ONE_MINUS_DST_ALPHA);
+        lv_eve_draw_rect_simple(area_inner.x1, area_inner.y1, area_inner.x2, area_inner.y2, rin);
+    }
+
+    lv_eve_stencil_func(EVE_NOTEQUAL, 1, 255);
+    lv_eve_blend_func(EVE_SRC_ALPHA, EVE_ONE_MINUS_SRC_ALPHA);
+
+    lv_eve_color_opa(dsc->opa);
+    lv_eve_draw_rect_simple(coords->x1, coords->y1, coords->x2, coords->y2, rout);
+
+    lv_eve_restore_context();
+}
+
+#endif /*LV_USE_DRAW_EVE*/
+

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_image.c

@@ -0,0 +1,299 @@
+/**
+ * @file lv_draw_eve_image.c
+ *
+ */
+
+/*  Created on: 17 jun 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+
+#include "../lv_draw_image_private.h"
+#include "lv_draw_eve_ram_g.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void convert_row_rgb565a8_to_argb4444(const uint8_t * src, const uint8_t * src_alpha, uint8_t * dst,
+                                             uint32_t width);
+static void convert_row_argb8888_to_argb4444(const uint8_t * src, uint8_t * dst, uint32_t width);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define F16_PIVOT_SHIFT(x) ((int32_t)((((x) >> 1)) * 65536L))
+#define F16_SCALE_DIV_256(x) ((int32_t)(((x) / 256.0f) * 65536L))
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc, const lv_area_t * coords)
+{
+    if(!lv_draw_eve_image_src_check(draw_dsc->src)) {
+        return;
+    }
+
+    const lv_image_dsc_t * img_dsc = draw_dsc->src;
+
+    int32_t src_w = img_dsc->header.w;
+    int32_t src_h = img_dsc->header.h;
+    int32_t src_stride = img_dsc->header.stride;
+    lv_color_format_t src_cf = img_dsc->header.cf;
+
+    if(src_stride == 0) {
+        src_stride = src_w * lv_color_format_get_size(src_cf);
+    }
+
+    uint8_t eve_format;
+    int32_t eve_stride;
+
+    switch(src_cf) {
+        case LV_COLOR_FORMAT_L8:
+            eve_format = EVE_L8;
+            eve_stride = src_stride;
+            break;
+        case LV_COLOR_FORMAT_RGB565:
+            eve_format = EVE_RGB565;
+            eve_stride = src_stride;
+            break;
+        case LV_COLOR_FORMAT_RGB565A8:
+        case LV_COLOR_FORMAT_ARGB8888:
+            eve_format = EVE_ARGB4;
+            eve_stride = src_w * 2;
+            break;
+        default :
+            LV_ASSERT(0);
+    }
+
+    uint32_t ramg_addr = lv_draw_eve_image_upload_image(true, img_dsc);
+    if(ramg_addr == LV_DRAW_EVE_RAMG_OUT_OF_RAMG) {
+        LV_LOG_WARN("Could not load image because space could not be allocated in RAM_G.");
+        return;
+    }
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+
+    lv_eve_save_context();
+
+    lv_eve_color_opa(draw_dsc->opa);
+
+    if(draw_dsc->recolor_opa > LV_OPA_MIN) {
+        lv_eve_color(lv_color_mix(draw_dsc->recolor, lv_color_white(), draw_dsc->recolor_opa));
+    }
+
+    lv_eve_primitive(LV_EVE_PRIMITIVE_BITMAPS);
+    lv_eve_bitmap_source(ramg_addr);
+    /*real height and width is mandatory for rotation and scale (Clip Area)*/
+    lv_eve_bitmap_size(EVE_NEAREST, EVE_BORDER, EVE_BORDER, src_w, src_h);
+
+    lv_eve_bitmap_layout(eve_format, eve_stride, src_h);
+
+    if(draw_dsc->rotation || draw_dsc->scale_x != LV_SCALE_NONE || draw_dsc->scale_y != LV_SCALE_NONE) {
+        EVE_cmd_dl_burst(CMD_LOADIDENTITY);
+
+        EVE_cmd_translate_burst(F16(coords->x1 - t->clip_area.x1 + draw_dsc->pivot.x),
+                                F16(coords->y1 - t->clip_area.y1 + draw_dsc->pivot.y));
+        if(draw_dsc->scale_x != LV_SCALE_NONE || draw_dsc->scale_y != LV_SCALE_NONE) {
+            /*Image Scale*/
+            EVE_cmd_scale_burst(F16_SCALE_DIV_256(draw_dsc->scale_x), F16_SCALE_DIV_256(draw_dsc->scale_y));
+        }
+        if(draw_dsc->rotation != 0) {
+            /*Image Rotate*/
+            EVE_cmd_rotate_burst(DEGREES(draw_dsc->rotation));
+        }
+        EVE_cmd_translate_burst(-F16(draw_dsc->pivot.x), -F16(draw_dsc->pivot.y));
+        EVE_cmd_dl_burst(CMD_SETMATRIX);
+        EVE_cmd_dl_burst(CMD_LOADIDENTITY);
+        lv_eve_vertex_2f(t->clip_area.x1, t->clip_area.y1);
+    }
+    else {
+        lv_eve_vertex_2f(coords->x1, coords->y1);
+    }
+    lv_eve_restore_context();
+}
+
+bool lv_draw_eve_image_src_check(const void * src)
+{
+    if(lv_image_src_get_type(src) != LV_IMAGE_SRC_VARIABLE) {
+        LV_LOG_WARN("lv_draw_eve can only render images from variables (not files or symbols) for now.");
+        return false;
+    }
+
+    const lv_image_dsc_t * img_dsc = src;
+
+    switch(img_dsc->header.cf) {
+        case LV_COLOR_FORMAT_L8:
+        case LV_COLOR_FORMAT_RGB565:
+        case LV_COLOR_FORMAT_RGB565A8:
+        case LV_COLOR_FORMAT_ARGB8888:
+            break;
+        default :
+            LV_LOG_WARN("lv_draw_eve can only render L8, RGB565, RGB565A8, and ARGB8888 images for now.");
+            return false;
+    }
+
+    return true;
+}
+
+uint32_t lv_draw_eve_image_upload_image(bool burst_is_active, const lv_image_dsc_t * img_dsc)
+{
+    const uint8_t * src_buf = img_dsc->data;
+    int32_t src_w = img_dsc->header.w;
+    int32_t src_h = img_dsc->header.h;
+    int32_t src_stride = img_dsc->header.stride;
+    lv_color_format_t src_cf = img_dsc->header.cf;
+
+    if(src_stride == 0) {
+        src_stride = src_w * lv_color_format_get_size(src_cf);
+    }
+
+    int32_t eve_stride;
+    uint8_t eve_alignment;
+
+    switch(src_cf) {
+        case LV_COLOR_FORMAT_L8:
+            eve_stride = src_stride;
+            eve_alignment = 1;
+            break;
+        case LV_COLOR_FORMAT_RGB565:
+            eve_stride = src_stride;
+            eve_alignment = 2;
+            break;
+        case LV_COLOR_FORMAT_RGB565A8:
+        case LV_COLOR_FORMAT_ARGB8888:
+            eve_stride = src_w * 2;
+            eve_alignment = 2;
+            break;
+        default :
+            LV_ASSERT(0);
+    }
+
+    int32_t eve_size = eve_stride * src_h;
+
+    uint32_t ramg_addr;
+    bool img_is_loaded = lv_draw_eve_ramg_get_addr(&ramg_addr, (uintptr_t) src_buf, eve_size, eve_alignment);
+
+    /* New image to load  */
+    if(!img_is_loaded && ramg_addr != LV_DRAW_EVE_RAMG_OUT_OF_RAMG) {
+
+        /* Load image to RAM_G */
+
+        if(burst_is_active) {
+            EVE_end_cmd_burst();
+        }
+
+        switch(src_cf) {
+            case LV_COLOR_FORMAT_L8:
+            case LV_COLOR_FORMAT_RGB565:
+                EVE_memWrite_flash_buffer(ramg_addr, src_buf, eve_size);
+                break;
+            case LV_COLOR_FORMAT_RGB565A8: {
+                    uint8_t * tmp_buf = lv_malloc(eve_stride);
+                    LV_ASSERT_MALLOC(tmp_buf);
+                    const uint8_t * src_alpha_buf = src_buf + src_h * src_stride;
+                    int32_t src_alpha_stride = src_stride / 2;
+                    for(uint32_t y = 0; y < src_h; y++) {
+                        convert_row_rgb565a8_to_argb4444(src_buf + y * src_stride, src_alpha_buf + y * src_alpha_stride, tmp_buf, src_w);
+                        EVE_memWrite_flash_buffer(ramg_addr + y * eve_stride, tmp_buf, eve_stride);
+                    }
+                    lv_free(tmp_buf);
+                    break;
+                }
+            case LV_COLOR_FORMAT_ARGB8888: {
+                    uint8_t * tmp_buf = lv_malloc(eve_stride);
+                    LV_ASSERT_MALLOC(tmp_buf);
+                    for(uint32_t y = 0; y < src_h; y++) {
+                        convert_row_argb8888_to_argb4444(src_buf + y * src_stride, tmp_buf, src_w);
+                        EVE_memWrite_flash_buffer(ramg_addr + y * eve_stride, tmp_buf, eve_stride);
+                    }
+                    lv_free(tmp_buf);
+                    break;
+                }
+            default:
+                LV_ASSERT(0);
+        }
+
+        if(burst_is_active) {
+            EVE_start_cmd_burst();
+        }
+    }
+
+    return ramg_addr;
+}
+
+
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void convert_row_rgb565a8_to_argb4444(const uint8_t * src, const uint8_t * src_alpha, uint8_t * dst,
+                                             uint32_t width)
+{
+    for(uint32_t x = 0; x < width; x++) {
+        uint16_t rgb565 = ((const uint16_t *) src)[x];
+
+        uint8_t r5 = (rgb565 >> 11) & 0x1F;
+        uint8_t g6 = (rgb565 >> 5) & 0x3F;
+        uint8_t b5 = rgb565 & 0x1F;
+        uint8_t alpha = src_alpha[x];
+
+        uint8_t r4 = r5 >> 1;
+        uint8_t g4 = g6 >> 2;
+        uint8_t b4 = b5 >> 1;
+        uint8_t a4 = alpha >> 4;
+
+        uint16_t argb4444 = (a4 << 12) | (r4 << 8) | (g4 << 4) | b4;
+
+        dst[2 * x] = argb4444 & 0xFF;
+        dst[2 * x + 1] = (argb4444 >> 8) & 0xFF;
+    }
+}
+
+static void convert_row_argb8888_to_argb4444(const uint8_t * src, uint8_t * dst, uint32_t width)
+{
+    for(uint32_t x = 0; x < width; x++) {
+        uint8_t blue = src[4 * x];
+        uint8_t green = src[4 * x + 1];
+        uint8_t red = src[4 * x + 2];
+        uint8_t alpha = src[4 * x + 3];
+
+        uint8_t r4 = red >> 4;
+        uint8_t g4 = green >> 4;
+        uint8_t b4 = blue >> 4;
+        uint8_t a4 = alpha >> 4;
+
+        uint16_t argb4444 = (a4 << 12) | (r4 << 8) | (g4 << 4) | b4;
+
+        dst[2 * x] = argb4444 & 0xFF;
+        dst[2 * x + 1] = (argb4444 >> 8) & 0xFF;
+    }
+}
+
+#endif /*LV_USE_DRAW_EVE*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_letter.c

@@ -0,0 +1,233 @@
+/**
+ * @file lv_draw_eve_letter.c
+ *
+ */
+
+/*  Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+
+#include "../lv_draw_private.h"
+#include "../lv_draw_label_private.h"
+#include "../lv_draw_rect.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void lv_draw_eve_letter_cb(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_draw_dsc,
+                                  lv_draw_fill_dsc_t * fill_draw_dsc, const lv_area_t * fill_area);
+static void font_bitmap_to_ramg(uint32_t addr, const uint8_t * src, uint32_t width,
+                                uint32_t height, uint8_t src_stride_align);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define GET_NIBBLE_1(w) ((uint8_t) ((w) >> 4))
+#define GET_NIBBLE_2(w) ((uint8_t) ((w) & 0xf))
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_label(lv_draw_task_t * t, const lv_draw_label_dsc_t * dsc, const lv_area_t * coords)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+    lv_eve_save_context();
+    lv_eve_primitive(LV_EVE_PRIMITIVE_BITMAPS);
+    lv_draw_label_iterate_characters(t, dsc, coords, lv_draw_eve_letter_cb);
+    lv_eve_restore_context();
+}
+
+bool lv_draw_eve_label_font_check(const lv_font_t * font)
+{
+    if(font->get_glyph_bitmap != lv_font_get_bitmap_fmt_txt) {
+        LV_LOG_WARN("lv_draw_eve can only render static fonts for now.");
+        return false;
+    }
+
+    const lv_font_fmt_txt_dsc_t * font_dsc = font->dsc;
+
+    /* Only 4 bpp is supported for now. Support for 1 and 8 bpp can be added. (EVE_L1, EVE_L8) */
+    if(font_dsc->bpp != 4) {
+        LV_LOG_WARN("lv_draw_eve can only render static fonts for now.");
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t lv_draw_eve_label_upload_glyph(bool burst_is_active, const lv_font_fmt_txt_dsc_t * font_dsc,
+                                        uint32_t gid_index)
+{
+    const lv_font_fmt_txt_glyph_dsc_t * glyph_dsc = &font_dsc->glyph_dsc[gid_index];
+    const uint8_t * glyph_bitmap = &font_dsc->glyph_bitmap[glyph_dsc->bitmap_index];
+
+    uint16_t g_box_w = glyph_dsc->box_w;
+    uint16_t g_box_h = glyph_dsc->box_h;
+
+    uint16_t g_aligned_stride = (g_box_w + 1) / 2;
+
+    uint32_t glyph_ramg_size = g_aligned_stride * g_box_h;
+
+    uint32_t ramg_addr;
+    uintptr_t glyph_ramg_key = (uintptr_t) glyph_bitmap;
+    bool font_is_loaded = lv_draw_eve_ramg_get_addr(&ramg_addr, glyph_ramg_key, glyph_ramg_size, 1);
+
+    /* If the font is not yet loaded in ramG, load it */
+    if(!font_is_loaded && ramg_addr != LV_DRAW_EVE_RAMG_OUT_OF_RAMG) {
+        if(burst_is_active) {
+            EVE_end_cmd_burst();
+        }
+
+        uint8_t glyph_bitmap_stride_align = font_dsc->stride;
+        font_bitmap_to_ramg(ramg_addr, glyph_bitmap, g_box_w, g_box_h, glyph_bitmap_stride_align);
+
+        if(burst_is_active) {
+            EVE_start_cmd_burst();
+        }
+    }
+
+    return ramg_addr;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_draw_eve_letter_cb(lv_draw_task_t * t, lv_draw_glyph_dsc_t * glyph_draw_dsc,
+                                  lv_draw_fill_dsc_t * fill_draw_dsc, const lv_area_t * fill_area)
+{
+
+    if(fill_draw_dsc && fill_area) {
+        /* draw UNDERLINE and STRIKETHROUGH */
+        lv_eve_draw_rect_simple(fill_area->x1, fill_area->y1, fill_area->x2, fill_area->y2, 0);
+    }
+
+    if(glyph_draw_dsc == NULL)
+        return;  /* Important */
+
+    const lv_font_t * font = glyph_draw_dsc->g->resolved_font;
+
+    if(!lv_draw_eve_label_font_check(font)) {
+        return;
+    }
+
+    const lv_font_fmt_txt_dsc_t * font_dsc = font->dsc;
+    uint32_t gid_index = glyph_draw_dsc->g->gid.index;
+    const lv_font_fmt_txt_glyph_dsc_t * glyph_dsc = &font_dsc->glyph_dsc[gid_index];
+
+    uint16_t g_box_w = glyph_dsc->box_w;
+    uint16_t g_box_h = glyph_dsc->box_h;
+
+    uint16_t g_aligned_stride = (g_box_w + 1) / 2;
+
+    uint8_t bpp_eve = EVE_L4;
+
+    uint32_t ramg_addr = lv_draw_eve_label_upload_glyph(true, font_dsc, gid_index);
+    if(ramg_addr == LV_DRAW_EVE_RAMG_OUT_OF_RAMG) {
+        LV_LOG_WARN("Could not load glyph because space could not be allocated in RAM_G.");
+        return;
+    }
+
+    lv_eve_color_opa(glyph_draw_dsc->opa);
+    lv_eve_color(glyph_draw_dsc->color);
+
+    lv_eve_bitmap_source(ramg_addr);
+
+    lv_eve_bitmap_size(EVE_NEAREST, EVE_BORDER, EVE_BORDER, g_box_w, g_box_h);
+    lv_eve_bitmap_layout(bpp_eve, g_aligned_stride, g_box_h);
+
+    lv_eve_vertex_2f(glyph_draw_dsc->letter_coords->x1, glyph_draw_dsc->letter_coords->y1);
+}
+
+static void font_bitmap_to_ramg(uint32_t addr, const uint8_t * src, uint32_t width,
+                                uint32_t height, uint8_t src_stride_align)
+{
+    uint32_t stride = (width + 1) / 2;
+
+    if(src_stride_align == 1 || (src_stride_align == 0 && width % 2 == 0)) {
+        uint32_t size = stride * height;
+        EVE_memWrite_flash_buffer(addr, src, size);
+        return;
+    }
+
+    if(src_stride_align > 0) {
+        uint32_t src_stride = LV_ALIGN_UP(stride, src_stride_align);
+        for(uint32_t y = 0; y < height; y++) {
+            EVE_memWrite_sram_buffer(addr, src, stride);
+            addr += stride;
+            src += src_stride;
+        }
+        return;
+    }
+
+    uint8_t * row_buf = lv_malloc(stride);
+    LV_ASSERT_MALLOC(row_buf);
+
+    uint32_t src_i = 0;
+    uint8_t nibble_1;
+    uint8_t nibble_2;
+    uint8_t key = 0;
+
+    /* Iterate through each row of the bitmap*/
+    for(uint32_t y = 0; y < height; y++) {
+        /* Iterate through each byte of the row*/
+        uint32_t row_i;
+        for(row_i = 0; row_i < (width / 2); ++row_i) {
+            /*Get the two nibbles from the current byte*/
+            if(key == 0) {
+                nibble_1 = GET_NIBBLE_1(src[src_i]);
+                nibble_2 = GET_NIBBLE_2(src[src_i]);
+            }
+            else {
+                nibble_1 = GET_NIBBLE_2(src[src_i - 1]);
+                nibble_2 = GET_NIBBLE_1(src[src_i]);
+            }
+
+            /*Combine the nibbles and assign the result to the output byte*/
+            row_buf[row_i] = (nibble_1 << 4) | nibble_2;
+
+            src_i++;
+        }
+
+        /*process the last remaining nibble*/
+        row_buf[row_i] =
+            (key == 0) ?
+            (GET_NIBBLE_1(src[src_i])) << 4 | 0x0 : (GET_NIBBLE_2(src[src_i - 1])) << 4 | 0x0;
+        key = (key == 0) ? 1 : 0;
+        src_i += (key == 1) ? 1 : 0;
+
+        EVE_memWrite_sram_buffer(addr, row_buf, stride);
+        addr += stride;
+    }
+
+    lv_free(row_buf);
+}
+
+
+#endif /*LV_USE_DRAW_EVE*/
+

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_line.c

@@ -0,0 +1,63 @@
+/**
+ * @file lv_draw_eve_line.c
+ *
+ */
+
+/*  Created on: 8 abr 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+#include "lv_eve.h"
+
+
+void lv_draw_eve_line(lv_draw_task_t * t, const lv_draw_line_dsc_t * dsc)
+{
+
+    if(dsc->width == 0)
+        return;
+    if(dsc->opa <= LV_OPA_MIN)
+        return;
+    if(dsc->p1.x == dsc->p2.x && dsc->p1.y == dsc->p2.y)
+        return;
+
+
+
+    uint32_t line_w = dsc->width * 8;
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+    lv_eve_save_context();
+    lv_eve_color_opa(dsc->opa);
+    lv_eve_color(dsc->color);
+
+    if(dsc->dash_gap || dsc->dash_width) {
+        LV_LOG_WARN("line dash_gap and dash_width not implemented by EVE yet.");
+    }
+    /* Check if it's a vertical or horizontal line without rounding */
+    bool is_vertical = (dsc->p1.x == dsc->p2.x);
+    bool is_horizontal = (dsc->p1.y == dsc->p2.y);
+    bool no_round = (!dsc->round_end || !dsc->round_start);
+
+    if((is_vertical || is_horizontal) && no_round) {
+        lv_eve_primitive(LV_EVE_PRIMITIVE_RECTS);
+        lv_eve_vertex_2f(dsc->p1.x, dsc->p1.y);
+        lv_eve_vertex_2f(dsc->p2.x, dsc->p2.y);
+    }
+    else {
+        /* Draw inclined line or line with rounding (not possible without rounding)*/
+        lv_eve_primitive(LV_EVE_PRIMITIVE_LINE_STRIP);
+        lv_eve_line_width(line_w);
+        lv_eve_vertex_2f(dsc->p1.x, dsc->p1.y);
+        lv_eve_vertex_2f(dsc->p2.x, dsc->p2.y);
+    }
+
+    lv_eve_restore_context();
+}
+
+#endif /*LV_USE_DRAW_EVE*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_private.h

@@ -0,0 +1,117 @@
+/**
+ * @file lv_draw_eve_private.h
+ *
+ */
+
+/*  Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+#ifndef LV_DRAW_EVE_PRIVATE_H
+#define LV_DRAW_EVE_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_eve.h"
+#if LV_USE_DRAW_EVE
+
+#include "lv_draw_eve_target.h"
+#include "lv_draw_eve_ram_g.h"
+#include "../lv_draw_private.h"
+#include "../../misc/lv_types.h"
+#include "../../core/lv_global.h"
+#include "../lv_draw_triangle.h"
+#include "../lv_draw_line.h"
+#include "../lv_draw_label.h"
+#include "../../font/lv_font_fmt_txt.h"
+#include "../lv_draw_arc.h"
+
+#if LV_DRAW_EVE_WRITE_BUFFER_SIZE != 0 && LV_DRAW_EVE_WRITE_BUFFER_SIZE < 4
+#warning LV_DRAW_EVE_WRITE_BUFFER_SIZE cannot be less than 4. Using 0 (buffering disabled).
+#define LV_DRAW_EVE_WRITE_BUFFER_SIZE_INTERNAL 0
+#else
+#define LV_DRAW_EVE_WRITE_BUFFER_SIZE_INTERNAL LV_DRAW_EVE_WRITE_BUFFER_SIZE
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    uintptr_t key;
+    uint32_t addr;
+} lv_draw_eve_ramg_hash_table_cell_t;
+
+typedef struct {
+    uint32_t ramg_addr_end;
+    uint32_t hash_table_cell_count;
+    uint32_t hash_table_cells_occupied;
+    lv_draw_eve_ramg_hash_table_cell_t * hash_table;
+} lv_draw_eve_ramg_t;
+
+struct _lv_draw_eve_unit_t {
+    lv_draw_unit_t base_unit;
+    lv_draw_task_t * task_act;
+    lv_display_t * disp;
+    lv_draw_eve_ramg_t ramg;
+    lv_draw_eve_parameters_t params;
+    lv_draw_eve_operation_cb_t op_cb;
+#if LV_DRAW_EVE_WRITE_BUFFER_SIZE_INTERNAL
+    uint32_t lv_eve_write_buf_len;
+    uint8_t lv_eve_write_buf[LV_DRAW_EVE_WRITE_BUFFER_SIZE_INTERNAL];
+#endif
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_eve_image(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                       const lv_area_t * coords);
+bool lv_draw_eve_image_src_check(const void * src);
+uint32_t lv_draw_eve_image_upload_image(bool burst_is_active, const lv_image_dsc_t * img_dsc);
+
+void lv_draw_eve_fill(lv_draw_task_t * t, const lv_draw_fill_dsc_t * dsc, const lv_area_t * coords);
+
+void lv_draw_eve_border(lv_draw_task_t * t, const lv_draw_border_dsc_t * dsc,
+                        const lv_area_t * coords);
+
+void lv_draw_eve_line(lv_draw_task_t * t, const lv_draw_line_dsc_t * dsc);
+
+void lv_draw_eve_label(lv_draw_task_t * t, const lv_draw_label_dsc_t * dsc,
+                       const lv_area_t * coords);
+bool lv_draw_eve_label_font_check(const lv_font_t * font);
+uint32_t lv_draw_eve_label_upload_glyph(bool burst_is_active, const lv_font_fmt_txt_dsc_t * font_dsc,
+                                        uint32_t gid_index);
+
+void lv_draw_eve_arc(lv_draw_task_t * t, const lv_draw_arc_dsc_t * dsc, const lv_area_t * coords);
+
+void lv_draw_eve_triangle(lv_draw_task_t * t, const lv_draw_triangle_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define DEGREES(n) ((65536UL * (n)) / 3600)
+#define F16(x)     ((int32_t)((x) * 65536L))
+
+#define lv_draw_eve_unit_g (LV_GLOBAL_DEFAULT()->draw_eve_unit)
+
+#endif /*LV_USE_DRAW_EVE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_EVE_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_ram_g.c

@@ -0,0 +1,221 @@
+/**
+ * @file lv_draw_eve_ram_g.c
+ *
+ */
+
+/*  Created on: 19 nov 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+#include "lv_draw_eve_ram_g.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define RAMG_DEBUG 0
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * STATIC PROTOTYPES
+ **********************/
+
+static void ramg_init(lv_draw_eve_ramg_t * ramg);
+static uint32_t hash_key(uintptr_t key);
+static uint32_t fnv_1a_hash(const void * src, size_t len);
+static void grow_hash_table(lv_draw_eve_ramg_t * ramg);
+
+#if RAMG_DEBUG
+    static void ramg_debug(lv_draw_eve_ramg_t * ramg, uint32_t key_hash, uint32_t table_index);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+bool lv_draw_eve_ramg_get_addr(uint32_t * addr_dst, uintptr_t key,
+                               uint32_t addr_size, uint32_t addr_align)
+{
+    LV_ASSERT(key != 0);
+
+    lv_draw_eve_ramg_t * ramg = &lv_draw_eve_unit_g->ramg;
+
+    if(ramg->hash_table_cell_count == 0) {
+        ramg_init(ramg);
+    }
+
+    uint32_t key_hash = hash_key(key);
+    uint32_t table_index = key_hash % ramg->hash_table_cell_count;
+    lv_draw_eve_ramg_hash_table_cell_t * cell;
+
+    while(1) {
+        cell = &ramg->hash_table[table_index];
+
+        if(cell->key == key) {
+#if RAMG_DEBUG
+            ramg_debug(ramg, key_hash, table_index);
+#endif
+
+            *addr_dst = cell->addr;
+            return true;
+        }
+
+        if(cell->key == 0) {
+            break;
+        }
+
+        table_index++;
+        if(table_index >= ramg->hash_table_cell_count) table_index = 0;
+    }
+
+    uint32_t addr_ret = LV_ALIGN_UP(ramg->ramg_addr_end, addr_align);
+    uint32_t addr_new_end = addr_ret + addr_size;
+
+    if(addr_new_end > 1024 * 1024) {
+        LV_LOG_WARN("EVE on-chip 1 MB RAM_G for images and fonts has run out.");
+        *addr_dst = LV_DRAW_EVE_RAMG_OUT_OF_RAMG;
+        return false;
+    }
+
+    ramg->ramg_addr_end = addr_new_end;
+    ramg->hash_table_cells_occupied++;
+
+    cell->key = key;
+    cell->addr = addr_ret;
+    *addr_dst = addr_ret;
+
+#if RAMG_DEBUG
+    ramg_debug(ramg, key_hash, table_index);
+#endif
+
+    if(ramg->hash_table_cells_occupied > ramg->hash_table_cell_count / 4 * 3) {
+        grow_hash_table(ramg);
+    }
+
+    return false;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void ramg_init(lv_draw_eve_ramg_t * ramg)
+{
+    ramg->hash_table_cell_count = 32;
+    ramg->hash_table = lv_calloc(32, sizeof(lv_draw_eve_ramg_hash_table_cell_t));
+    LV_ASSERT_MALLOC(ramg->hash_table);
+}
+
+static uint32_t hash_key(uintptr_t key)
+{
+    return fnv_1a_hash(&key, sizeof(key));
+}
+
+static uint32_t fnv_1a_hash(const void * src, size_t len)
+{
+    const uint8_t * src_u8 = src;
+    uint32_t hash = 2166136261u;
+    for(size_t i = 0; i < len; i++) {
+        hash ^= src_u8[i];
+        hash *= 16777619u;
+    }
+    return hash;
+}
+
+static void grow_hash_table(lv_draw_eve_ramg_t * ramg)
+{
+    uint32_t old_cell_count = ramg->hash_table_cell_count;
+    lv_draw_eve_ramg_hash_table_cell_t * old_hash_table = ramg->hash_table;
+
+    ramg->hash_table_cell_count += ramg->hash_table_cell_count / 2;
+    ramg->hash_table = lv_calloc(ramg->hash_table_cell_count,
+                                 sizeof(lv_draw_eve_ramg_hash_table_cell_t));
+    LV_ASSERT_MALLOC(ramg->hash_table);
+
+    for(uint32_t i = 0; i < old_cell_count; i++) {
+        lv_draw_eve_ramg_hash_table_cell_t * old_cell = &old_hash_table[i];
+
+        if(old_cell->key == 0) continue;
+
+        uint32_t key_hash = hash_key(old_cell->key);
+        uint32_t new_table_index = key_hash % ramg->hash_table_cell_count;
+        lv_draw_eve_ramg_hash_table_cell_t * new_cell_dst = &ramg->hash_table[new_table_index];
+
+        while(new_cell_dst->key != 0) {
+            new_table_index++;
+            if(new_table_index >= ramg->hash_table_cell_count) new_table_index = 0;
+            new_cell_dst = &ramg->hash_table[new_table_index];
+        }
+        *new_cell_dst = *old_cell;
+    }
+
+    lv_free(old_hash_table);
+}
+
+#if RAMG_DEBUG
+/*
+Print tables like this:
+    113 kB of RAM_G used
+    ================================-==-=====---=---===---=====-=-=-=-==--=======----=-==-==---=--===--=-=-=========================
+    ========^$==========--=-==-=-=--=--=========---=----========-------===--=====----=======--=====--====--=====-=--=-=
+
+'-' unoccupied cells
+'=' occupied cells
+'^' where the hash pointed to in the table initially and linear probing started
+'$' where linear probing ended because a matching or unoccupied cell
+    was found. This symbol is not shown if the initial guess was correct.
+
+This example has 244 cells. Each cell uses 8 bytes of local RAM, so just under 2 kB.
+Each cell represents an allocation in EVE RAM_G. The RAM_G allocation sizes are not
+represented in this table, except for the overall "113 kB of RAM_G used" message.
+*/
+static void ramg_debug(lv_draw_eve_ramg_t * ramg, uint32_t key_hash, uint32_t table_index)
+{
+    uint32_t table_index_initial_guess = key_hash % ramg->hash_table_cell_count;
+
+    lv_log("%u kB of RAM_G used\n", (unsigned) ramg->ramg_addr_end / 1024);
+
+    for(uint32_t i = 0; i < ramg->hash_table_cell_count; i++) {
+        if(i != 0 && i % 128 == 0) {
+            lv_log("\n");
+        }
+
+        if(i == table_index_initial_guess) {
+            lv_log("^");
+        }
+        else if(i == table_index) {
+            lv_log("$");
+        }
+        else if(ramg->hash_table[i].key) {
+            lv_log("=");
+        }
+        else {
+            lv_log("-");
+        }
+    }
+
+    lv_log("\n\n");
+}
+#endif
+
+#endif/*LV_USE_EVE_DRAW*/
+

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_ram_g.h

@@ -0,0 +1,48 @@
+/**
+ * @file lv_draw_eve_ram_g.h
+ *
+ */
+
+/*  Created on: 19 nov 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+#ifndef LV_DRAW_EVE_RAM_G_H
+#define LV_DRAW_EVE_RAM_G_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve.h"
+#if LV_USE_DRAW_EVE
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_DRAW_EVE_RAMG_OUT_OF_RAMG UINT32_MAX
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+bool lv_draw_eve_ramg_get_addr(uint32_t * addr_dst, uintptr_t key,
+                               uint32_t addr_size, uint32_t addr_align);
+
+#endif/*LV_USE_DRAW_EVE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* LV_DRAW_EVE_RAM_G_H */

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_target.h

@@ -0,0 +1,79 @@
+/**
+ * @file lv_draw_eve_target.h
+ *
+ */
+
+#ifndef LV_DRAW_EVE_TARGET_H
+#define LV_DRAW_EVE_TARGET_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_DRAW_EVE
+
+#include "../../misc/lv_types.h"
+#include LV_STDBOOL_INCLUDE
+#include LV_STDINT_INCLUDE
+
+typedef struct {
+    uint16_t hor_res;          /**< active display width */
+    uint16_t ver_res;          /**< active display height */
+    uint16_t hcycle;           /**< total number of clocks per line, incl front/back porch */
+    uint16_t hoffset;          /**< start of active line */
+    uint16_t hsync0;           /**< start of horizontal sync pulse */
+    uint16_t hsync1;           /**< end of horizontal sync pulse */
+    uint16_t vcycle;           /**< total number of lines per screen, including pre/post */
+    uint16_t voffset;          /**< start of active screen */
+    uint16_t vsync0;           /**< start of vertical sync pulse */
+    uint16_t vsync1;           /**< end of vertical sync pulse */
+    uint8_t swizzle;           /**< FT8xx output to LCD - pin order */
+    uint8_t pclkpol;           /**< LCD data is clocked in on this PCLK edge */
+    uint8_t cspread;           /**< helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
+    uint8_t pclk;              /**< 60MHz / pclk = pclk frequency */
+    bool has_crystal;          /**< has an external clock crystal */
+    bool has_gt911;            /**< has a touch controller */
+    uint8_t backlight_pwm;     /**< backlight PWM duty cycle 0 = off, 128 = max */
+    uint16_t backlight_freq;   /**< backlight PWM frequency. try 4000 if unsure */
+} lv_draw_eve_parameters_t;
+
+typedef enum {
+    LV_DRAW_EVE_OPERATION_POWERDOWN_SET,   /**< set the "PD_N" pin low */
+    LV_DRAW_EVE_OPERATION_POWERDOWN_CLEAR, /**< set the "PD_N" pin high */
+    LV_DRAW_EVE_OPERATION_CS_ASSERT,       /**< set the "CS_N" pin low */
+    LV_DRAW_EVE_OPERATION_CS_DEASSERT,     /**< set the "CS_N" pin high */
+    LV_DRAW_EVE_OPERATION_SPI_SEND,        /**< send `length` bytes of `data` over SPI */
+    LV_DRAW_EVE_OPERATION_SPI_RECEIVE      /**< receive `length` bytes into `data` from SPI */
+} lv_draw_eve_operation_t;
+
+typedef void (*lv_draw_eve_operation_cb_t)(lv_display_t * disp, lv_draw_eve_operation_t operation, void * data,
+                                           uint32_t length);
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_DRAW_EVE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_EVE_TARGET_H*/

components/easylvgl/lvgl9/src/draw/eve/lv_draw_eve_triangle.c

@@ -0,0 +1,127 @@
+/**
+ * @file lv_draw_eve_triangle.c
+ *
+ */
+
+/*  Created on: 10 ene 2024
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve_private.h"
+#if LV_USE_DRAW_EVE
+
+#include "../../misc/lv_math.h"
+#include "../../stdlib/lv_mem.h"
+#include "../../misc/lv_area_private.h"
+#include "../../misc/lv_color.h"
+#include "../../stdlib/lv_string.h"
+#include "lv_eve.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_eve_triangle(lv_draw_task_t * t, const lv_draw_triangle_dsc_t * dsc)
+{
+
+    lv_area_t tri_area;
+    tri_area.x1 = (int32_t)LV_MIN3(dsc->p[0].x, dsc->p[1].x, dsc->p[2].x);
+    tri_area.y1 = (int32_t)LV_MIN3(dsc->p[0].y, dsc->p[1].y, dsc->p[2].y);
+    tri_area.x2 = (int32_t)LV_MAX3(dsc->p[0].x, dsc->p[1].x, dsc->p[2].x);
+    tri_area.y2 = (int32_t)LV_MAX3(dsc->p[0].y, dsc->p[1].y, dsc->p[2].y);
+
+    bool is_common;
+    lv_area_t draw_area;
+    is_common = lv_area_intersect(&draw_area, &tri_area, &t->clip_area);
+    if(!is_common) return;
+
+    lv_point_t p[3];
+    /*If there is a vertical side use it as p[0] and p[1]*/
+    if(dsc->p[0].x == dsc->p[1].x) {
+        p[0] = lv_point_from_precise(&dsc->p[0]);
+        p[1] = lv_point_from_precise(&dsc->p[1]);
+        p[2] = lv_point_from_precise(&dsc->p[2]);
+    }
+    else if(dsc->p[0].x == dsc->p[2].x) {
+        p[0] = lv_point_from_precise(&dsc->p[0]);
+        p[1] = lv_point_from_precise(&dsc->p[2]);
+        p[2] = lv_point_from_precise(&dsc->p[1]);
+    }
+    else if(dsc->p[1].x == dsc->p[2].x) {
+        p[0] = lv_point_from_precise(&dsc->p[1]);
+        p[1] = lv_point_from_precise(&dsc->p[2]);
+        p[2] = lv_point_from_precise(&dsc->p[0]);
+    }
+    else {
+        p[0] = lv_point_from_precise(&dsc->p[0]);
+        p[1] = lv_point_from_precise(&dsc->p[1]);
+        p[2] = lv_point_from_precise(&dsc->p[2]);
+
+        /*Set the smallest y as p[0]*/
+        if(p[0].y > p[1].y) lv_point_swap(&p[0], &p[1]);
+        if(p[0].y > p[2].y) lv_point_swap(&p[0], &p[2]);
+
+        /*Set the greatest y as p[1]*/
+        if(p[1].y < p[2].y) lv_point_swap(&p[1], &p[2]);
+    }
+
+    /*Be sure p[0] is on the top*/
+    if(p[0].y > p[1].y) lv_point_swap(&p[0], &p[1]);
+
+    lv_eve_save_context();
+
+    lv_eve_scissor(t->clip_area.x1, t->clip_area.y1, t->clip_area.x2, t->clip_area.y2);
+
+    lv_eve_color(dsc->color);
+    lv_eve_color_opa(dsc->opa);
+
+    lv_eve_color_mask(0, 0, 0, 0);
+    lv_eve_stencil_op(EVE_KEEP, EVE_INVERT);
+    lv_eve_stencil_func(EVE_ALWAYS, 255, 255);
+    lv_eve_primitive(LV_EVE_PRIMITIVE_EDGE_STRIP_A);
+
+    lv_eve_vertex_2f(p[0].x, p[0].y);
+    lv_eve_vertex_2f(p[1].x, p[1].y);
+    lv_eve_vertex_2f(p[2].x, p[2].y);
+
+    lv_eve_color_mask(1, 1, 1, 1);
+    lv_eve_stencil_func(EVE_EQUAL, 255, 255) ;
+
+    lv_eve_vertex_2f(0, 0);
+    lv_eve_vertex_2f(1022, 0);
+
+    lv_eve_restore_context();
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_DRAW_EVE*/
+
+

components/easylvgl/lvgl9/src/draw/eve/lv_eve.c

@@ -0,0 +1,265 @@
+/**
+ * @file lv_eve.c
+ *
+ */
+
+/*  Created on: 8 jun 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_eve.h"
+#if LV_USE_DRAW_EVE
+#include "lv_eve.h"
+#include "../../libs/FT800-FT813/EVE_commands.h"
+
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+static uint16_t scissor_x1 = 0;
+static uint16_t scissor_y1 = 0;
+static uint16_t scissor_x2 = 0;
+static uint16_t scissor_y2 = 0;
+
+static lv_eve_drawing_context_t ct = {
+    .primitive = LV_EVE_PRIMITIVE_ZERO_VALUE,
+    .color = {0xff, 0xff, 0xff},
+    .opa = 255,
+    .line_width = 1,  /* for format(0) */
+    .point_size = 1,
+    .color_mask = {1, 1, 1, 1},
+    .stencil_func = {EVE_ALWAYS, 0, 255},
+    .stencil_op = {EVE_KEEP, EVE_KEEP},
+    .blend_func = {EVE_SRC_ALPHA, EVE_ONE_MINUS_SRC_ALPHA},
+    .scx = 0,
+    .scy = 0,
+};
+
+static lv_eve_drawing_context_t ct_temp;
+
+static lv_eve_drawing_state_t st;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_eve_save_context(void)
+{
+    EVE_cmd_dl_burst(DL_SAVE_CONTEXT);
+    ct_temp = ct;
+}
+
+void lv_eve_restore_context(void)
+{
+    EVE_cmd_dl_burst(DL_RESTORE_CONTEXT);
+    ct = ct_temp;
+}
+
+
+void lv_eve_primitive(uint8_t context)
+{
+    if(context != ct.primitive && context != LV_EVE_PRIMITIVE_ZERO_VALUE) {
+        EVE_cmd_dl_burst(DL_BEGIN | context);
+        ct.primitive = context;
+    }
+}
+
+void lv_eve_scissor(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
+{
+    if(x1 != scissor_x1 || y1 != scissor_y1) {
+        int16_t adjusted_x1 = x1 > 0 ? x1 - 1 : 0;
+        int16_t adjusted_y1 = y1 > 0 ? y1 - 1 : 0;
+        EVE_cmd_dl_burst(SCISSOR_XY(adjusted_x1, adjusted_y1));
+        scissor_x1 = x1;
+        scissor_y1 = y1;
+    }
+
+    if(x2 != scissor_x2 || y2 != scissor_y2) {
+        uint16_t w = x2 - x1 + 3;
+        uint16_t h = y2 - y1 + 3;
+        EVE_cmd_dl_burst(SCISSOR_SIZE(w, h));
+        scissor_x2 = x2;
+        scissor_y2 = y2;
+    }
+}
+
+void lv_eve_color(lv_color_t color)
+{
+    if((ct.color.red != color.red) || (ct.color.green != color.green) || (ct.color.blue != color.blue)) {
+        EVE_cmd_dl_burst(COLOR_RGB(color.red, color.green, color.blue));
+        ct.color = color;
+    }
+}
+
+void lv_eve_color_mask(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+{
+    if((ct.color_mask[0] != r) ||
+       (ct.color_mask[1] != g) ||
+       (ct.color_mask[2] != b) ||
+       (ct.color_mask[3] != a)) {
+
+        EVE_cmd_dl_burst(COLOR_MASK(r, g, b, a));
+        ct.color_mask[0] = r;
+        ct.color_mask[1] = g;
+        ct.color_mask[2] = b;
+        ct.color_mask[3] = a;
+    }
+}
+
+void lv_eve_stencil_func(uint8_t func, uint8_t ref, uint8_t mask)
+{
+    if(func != ct.stencil_func[0] || ref != ct.stencil_func[1] || mask != ct.stencil_func[2]) {
+
+        EVE_cmd_dl_burst(STENCIL_FUNC(func, ref, mask));
+        ct.stencil_func[0] = func;
+        ct.stencil_func[1] = ref;
+        ct.stencil_func[2] = mask;
+    }
+}
+
+void lv_eve_stencil_op(uint8_t sfail, uint8_t spass)
+{
+    if(sfail != ct.stencil_op[0] || spass != ct.stencil_op[1]) {
+        EVE_cmd_dl_burst(STENCIL_OP(sfail, spass));
+        ct.stencil_op[0] = sfail;
+        ct.stencil_op[1] = spass;
+
+    }
+}
+
+void lv_eve_blend_func(uint8_t src, uint8_t dst)
+{
+    if(src != ct.blend_func[0] || dst != ct.blend_func[1]) {
+        EVE_cmd_dl_burst(BLEND_FUNC(src, dst));
+        ct.blend_func[0] = src;
+        ct.blend_func[1] = dst;
+    }
+}
+
+void lv_eve_color_opa(lv_opa_t opa)
+{
+    if(opa != ct.opa) {
+        EVE_cmd_dl_burst(COLOR_A(opa));
+        ct.opa = opa;
+    }
+}
+
+void lv_eve_line_width(int32_t width)
+{
+    if(width != ct.line_width) {
+        EVE_cmd_dl_burst(LINE_WIDTH(width));
+        ct.line_width = width;
+    }
+}
+
+void lv_eve_point_size(uint16_t radius)
+{
+    if(radius != ct.point_size) {
+        EVE_cmd_dl_burst(POINT_SIZE(radius * 16));
+        ct.point_size = radius;
+    }
+}
+
+void lv_eve_vertex_2f(int16_t x, int16_t y)
+{
+    EVE_cmd_dl_burst(VERTEX2F(x, y));
+}
+
+void lv_eve_draw_circle_simple(int16_t coord_x1, int16_t coord_y1, uint16_t radius_t)
+{
+    lv_eve_primitive(LV_EVE_PRIMITIVE_POINTS);
+    lv_eve_point_size(radius_t);
+    lv_eve_vertex_2f(coord_x1, coord_y1);
+}
+
+
+void lv_eve_draw_rect_simple(int16_t coord_x1, int16_t coord_y1, int16_t coord_x2, int16_t coord_y2, uint16_t radius)
+{
+    lv_eve_primitive(LV_EVE_PRIMITIVE_RECTS);
+    if(radius > 1) {
+        lv_eve_line_width(radius * 16);
+    }
+
+    lv_eve_vertex_2f(coord_x1 + radius, coord_y1 + radius);
+    lv_eve_vertex_2f(coord_x2 - radius, coord_y2 - radius);
+}
+
+void lv_eve_mask_round(int16_t coord_x1, int16_t coord_y1, int16_t coord_x2, int16_t coord_y2, int16_t radius)
+{
+    lv_eve_color_mask(0, 0, 0, 1);
+    EVE_cmd_dl_burst(CLEAR(1, 1, 1));
+
+
+    lv_eve_draw_rect_simple(coord_x1, coord_y1, coord_x2, coord_y2, radius);
+    lv_eve_color_mask(1, 1, 1, 0);
+    lv_eve_blend_func(EVE_DST_ALPHA, EVE_ONE_MINUS_DST_ALPHA);
+}
+
+void lv_eve_bitmap_source(uint32_t addr)
+{
+    uint32_t bitmap_source = BITMAP_SOURCE(addr);
+    if(st.bitmap_source != bitmap_source) {
+        EVE_cmd_dl_burst(bitmap_source);
+        st.bitmap_source = bitmap_source;
+    }
+}
+
+void lv_eve_bitmap_size(uint8_t filter, uint8_t wrapx, uint8_t wrapy, uint16_t width, uint16_t height)
+{
+    uint32_t bitmap_size = BITMAP_SIZE(filter, wrapx, wrapy, width, height);
+    if(st.bitmap_size != bitmap_size) {
+        EVE_cmd_dl_burst(bitmap_size);
+        st.bitmap_size = bitmap_size;
+    }
+    /* set the high bits too, of the width and height */
+    uint32_t bitmap_size_h = BITMAP_SIZE_H(width, height);
+    if(st.bitmap_size_h != bitmap_size_h) {
+        EVE_cmd_dl_burst(bitmap_size_h);
+        st.bitmap_size_h = bitmap_size_h;
+    }
+}
+
+void lv_eve_bitmap_layout(uint8_t format, uint16_t linestride, uint16_t height)
+{
+    uint32_t bitmap_layout = BITMAP_LAYOUT(format, linestride, height);
+    if(st.bitmap_layout != bitmap_layout) {
+        EVE_cmd_dl_burst(bitmap_layout);
+        st.bitmap_layout = bitmap_layout;
+    }
+    /* set the high bits too, of the linestride and height */
+    uint32_t bitmap_layout_h = BITMAP_LAYOUT_H(linestride, height);
+    if(st.bitmap_layout_h != bitmap_layout_h) {
+        EVE_cmd_dl_burst(bitmap_layout_h);
+        st.bitmap_layout_h = bitmap_layout_h;
+    }
+}
+
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_DRAW_EVE*/

components/easylvgl/lvgl9/src/draw/eve/lv_eve.h

@@ -0,0 +1,151 @@
+/**
+ * @file lv_eve.h
+ *
+ */
+
+/*  Created on: 8 jun 2023
+ *      Author: juanj
+ *
+ *  Modified by LVGL
+ */
+
+#ifndef LV_EVE_H
+#define LV_EVE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_eve.h"
+
+#if LV_USE_DRAW_EVE
+
+#include "../../misc/lv_types.h"
+#include "../../misc/lv_color.h"
+#include "../../libs/FT800-FT813/EVE.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef enum {
+    LV_EVE_PRIMITIVE_ZERO_VALUE,
+    LV_EVE_PRIMITIVE_BITMAPS = 1UL,      /* Bitmap drawing primitive */
+    LV_EVE_PRIMITIVE_POINTS = 2UL,       /* Point drawing primitive */
+    LV_EVE_PRIMITIVE_LINES = 3UL,        /* Line drawing primitive */
+    LV_EVE_PRIMITIVE_LINE_STRIP = 4UL,   /* Line strip drawing primitive */
+    LV_EVE_PRIMITIVE_EDGE_STRIP_R = 5UL, /* Edge strip right side drawing primitive */
+    LV_EVE_PRIMITIVE_EDGE_STRIP_L = 6UL, /* Edge strip left side drawing primitive */
+    LV_EVE_PRIMITIVE_EDGE_STRIP_A = 7UL, /* Edge strip above drawing primitive */
+    LV_EVE_PRIMITIVE_EDGE_STRIP_B = 8UL, /* Edge strip below side drawing primitive */
+    LV_EVE_PRIMITIVE_RECTS = 9UL,        /* Rectangle drawing primitive */
+} lv_eve_primitive_t;
+
+
+typedef struct {
+    lv_eve_primitive_t primitive;
+    lv_color_t color;
+    lv_opa_t opa;
+    int32_t line_width;
+    uint16_t point_size;
+    uint8_t color_mask[4];
+    uint8_t stencil_func[3];
+    uint8_t stencil_op[2];
+    uint8_t blend_func[2];
+    uint16_t scx;
+    uint16_t scy;
+} lv_eve_drawing_context_t;
+
+/* drawing context that is not saved and restored
+ * by SAVE_CONTEXT and RESTORE_CONTEXT
+ */
+typedef struct {
+    uint32_t bitmap_source;
+    uint32_t bitmap_size;
+    uint32_t bitmap_size_h;
+    uint32_t bitmap_layout;
+    uint32_t bitmap_layout_h;
+} lv_eve_drawing_state_t;
+
+/**********************
+ *  GLOBAL PROTOTYPES
+ **********************/
+
+void lv_eve_save_context(void);
+void lv_eve_restore_context(void);
+void lv_eve_scissor(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
+void lv_eve_primitive(uint8_t context);
+void lv_eve_color(lv_color_t color);
+void lv_eve_color_opa(lv_opa_t opa);
+void lv_eve_line_width(int32_t width);
+void lv_eve_point_size(uint16_t radius);
+void lv_eve_vertex_2f(int16_t x, int16_t y);
+void lv_eve_color_mask(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+void lv_eve_stencil_func(uint8_t func, uint8_t ref, uint8_t mask);
+void lv_eve_stencil_op(uint8_t sfail, uint8_t spass);
+void lv_eve_blend_func(uint8_t src, uint8_t dst);
+
+void lv_eve_draw_circle_simple(int16_t coord_x1, int16_t coord_y1, uint16_t radius_t);
+void lv_eve_draw_rect_simple(int16_t coord_x1, int16_t coord_y1, int16_t coord_x2, int16_t coord_y2,
+                             uint16_t radius);
+void lv_eve_mask_round(int16_t coord_x1, int16_t coord_y1, int16_t coord_x2, int16_t coord_y2, int16_t radius);
+
+/**
+ * Set the bitmap source to `addr`. SPI transmission will occur unless it is already set to this value.
+ * The bitmap source is not part of the saved and restored context.
+ * @param addr    the remote EVE memory address to set as the bitmap source
+ */
+void lv_eve_bitmap_source(uint32_t addr);
+
+/**
+ * Set the bitmap size and sampling parameters. SPI transmission will occur unless the currently set parameters are already these.
+ * The bitmap size is not part of the saved and restored context.
+ * @param filter   the sampling method. Either EVE_NEAREST or EVE_BILINEAR
+ * @param wrapx    the out of bounds sampling behavior in the X direction. Either EVE_BORDER or EVE_REPEAT
+ * @param wrapy    the out of bounds sampling behavior in the Y direction. Either EVE_BORDER or EVE_REPEAT
+ * @param width    the width of the bitmap in pixels
+ * @param height   the height of the bitmap in pixels
+ */
+void lv_eve_bitmap_size(uint8_t filter, uint8_t wrapx, uint8_t wrapy, uint16_t width, uint16_t height);
+
+/**
+ * Set the bitmap format/layout parameters. SPI transmission will occur unless the currently set parameters are already these.
+ * The bitmap layout is not part of the saved and restored context.
+ * @param format      an eve color format value like EVE_RGB565
+ * @param linestride  the stride of the bitmap rows in bytes
+ * @param height      the number of rows in the bitmap
+ */
+void lv_eve_bitmap_layout(uint8_t format, uint16_t linestride, uint16_t height);
+
+/**********************
+ *  EXTERN VARIABLES
+ **********************/
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   INLINE FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_DRAW_EVE*/
+
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* LV_EVE_H */

components/easylvgl/lvgl9/src/draw/lv_draw.c

@@ -0,0 +1,715 @@
+/**
+ * @file lv_draw.c
+ *
+ */
+
+/**
+ * Modified by NXP in 2024
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_area_private.h"
+#include "../misc/lv_assert.h"
+#include "../misc/lv_event_private.h"
+#include "lv_draw_private.h"
+#include "lv_draw_mask_private.h"
+#include "lv_draw_vector_private.h"
+#include "lv_draw_3d.h"
+#include "sw/lv_draw_sw.h"
+#include "../display/lv_display_private.h"
+#include "../core/lv_global.h"
+#include "../core/lv_refr_private.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define _draw_info LV_GLOBAL_DEFAULT()->draw_info
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check, uint8_t draw_unit_id);
+static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp);
+static inline size_t get_draw_dsc_size(lv_draw_task_type_t type);
+static lv_draw_task_t * get_first_available_task(lv_layer_t * layer);
+
+#if LV_LOG_LEVEL <= LV_LOG_LEVEL_INFO
+static inline uint32_t get_layer_size_kb(uint32_t size_byte)
+{
+    return (size_byte + 1023) >> 10;
+}
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_init(void)
+{
+#if LV_USE_OS
+    lv_thread_sync_init(&_draw_info.sync);
+#endif
+}
+
+void lv_draw_deinit(void)
+{
+#if LV_USE_OS
+    lv_thread_sync_delete(&_draw_info.sync);
+#endif
+
+    lv_draw_unit_t * u = _draw_info.unit_head;
+    while(u) {
+        lv_draw_unit_t * cur_unit = u;
+        u = u->next;
+
+        if(cur_unit->delete_cb) cur_unit->delete_cb(cur_unit);
+        lv_free(cur_unit);
+    }
+    _draw_info.unit_head = NULL;
+}
+
+void * lv_draw_create_unit(size_t size)
+{
+    lv_draw_unit_t * new_unit = lv_malloc_zeroed(size);
+    LV_ASSERT_MALLOC(new_unit);
+    new_unit->next = _draw_info.unit_head;
+
+    _draw_info.unit_head = new_unit;
+    _draw_info.unit_cnt++;
+
+    new_unit->idx = _draw_info.unit_cnt;
+
+    return new_unit;
+}
+
+lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    size_t dsc_size = get_draw_dsc_size(type);
+    LV_ASSERT_FORMAT_MSG(dsc_size > 0, "Draw task size is 0 for type %d", type);
+    lv_draw_task_t * new_task = lv_malloc_zeroed(LV_ALIGN_UP(sizeof(lv_draw_task_t), 8) + dsc_size);
+    LV_ASSERT_MALLOC(new_task);
+    new_task->area = *coords;
+    new_task->_real_area = *coords;
+    new_task->target_layer = layer;
+    new_task->clip_area = layer->_clip_area;
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    new_task->matrix = layer->matrix;
+#endif
+    new_task->opa = layer->opa;
+    new_task->type = type;
+    new_task->draw_dsc = (uint8_t *)new_task + LV_ALIGN_UP(sizeof(lv_draw_task_t), 8);
+    new_task->state = LV_DRAW_TASK_STATE_WAITING;
+
+    /*Find the tail*/
+    if(layer->draw_task_head == NULL) {
+        layer->draw_task_head = new_task;
+    }
+    else {
+        lv_draw_task_t * tail = layer->draw_task_head;
+        while(tail->next) tail = tail->next;
+
+        tail->next = new_task;
+    }
+
+    LV_PROFILER_DRAW_END;
+    return new_task;
+}
+
+void lv_draw_finalize_task_creation(lv_layer_t * layer, lv_draw_task_t * t)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_dsc_base_t * base_dsc = t->draw_dsc;
+    base_dsc->layer = layer;
+
+    lv_draw_global_info_t * info = &_draw_info;
+
+    /*Send LV_EVENT_DRAW_TASK_ADDED and dispatch only on the "main" draw_task
+     *and not on the draw tasks added in the event.
+     *Sending LV_EVENT_DRAW_TASK_ADDED events might cause recursive event sends and besides
+     *dispatching might remove the "main" draw task while it's still being used in the event*/
+
+    if(info->task_running == false) {
+        if(base_dsc->obj && lv_obj_has_flag(base_dsc->obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS)) {
+            info->task_running = true;
+            lv_obj_send_event(base_dsc->obj, LV_EVENT_DRAW_TASK_ADDED, t);
+            info->task_running = false;
+        }
+
+        /*Let the draw units set their preference score*/
+        t->preference_score = 100;
+        t->preferred_draw_unit_id = 0;
+        lv_draw_unit_t * u = info->unit_head;
+        while(u) {
+            if(u->evaluate_cb) {
+                LV_PROFILER_DRAW_BEGIN_TAG("evaluate_cb");
+                LV_PROFILER_DRAW_BEGIN_TAG(u->name);
+                u->evaluate_cb(u, t);
+                LV_PROFILER_DRAW_END_TAG(u->name);
+                LV_PROFILER_DRAW_END_TAG("evaluate_cb");
+            }
+            u = u->next;
+        }
+        if(t->preferred_draw_unit_id == LV_DRAW_UNIT_NONE) {
+            LV_LOG_WARN("the draw task was not taken by any units");
+            t->state = LV_DRAW_TASK_STATE_FINISHED;
+        }
+        else {
+            lv_draw_dispatch();
+        }
+    }
+    else {
+        /*Let the draw units set their preference score*/
+        t->preference_score = 100;
+        t->preferred_draw_unit_id = 0;
+        lv_draw_unit_t * u = info->unit_head;
+        while(u) {
+            if(u->evaluate_cb) {
+                LV_PROFILER_DRAW_BEGIN_TAG("evaluate_cb");
+                LV_PROFILER_DRAW_BEGIN_TAG(u->name);
+                u->evaluate_cb(u, t);
+                LV_PROFILER_DRAW_END_TAG(u->name);
+                LV_PROFILER_DRAW_END_TAG("evaluate_cb");
+            }
+            u = u->next;
+        }
+    }
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_wait_for_finish(void)
+{
+#if LV_USE_OS
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_unit_t * u = _draw_info.unit_head;
+    while(u) {
+        if(u->wait_for_finish_cb) {
+            LV_PROFILER_DRAW_BEGIN_TAG("wait_for_finish_cb");
+            LV_PROFILER_DRAW_BEGIN_TAG(u->name);
+            u->wait_for_finish_cb(u);
+            LV_PROFILER_DRAW_END_TAG(u->name);
+            LV_PROFILER_DRAW_END_TAG("wait_for_finish_cb");
+        }
+        u = u->next;
+    }
+    LV_PROFILER_DRAW_END;
+#endif
+}
+
+void lv_draw_dispatch(void)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    bool task_dispatched = false;
+    lv_display_t * disp = lv_refr_get_disp_refreshing();
+    if(disp != NULL) {
+        lv_layer_t * layer = disp->layer_head;
+        while(layer) {
+            if(lv_draw_dispatch_layer(disp, layer))
+                task_dispatched = true;
+            layer = layer->next;
+        }
+    }
+    if(!task_dispatched) {
+        lv_draw_wait_for_finish();
+        lv_draw_dispatch_request();
+    }
+    LV_PROFILER_DRAW_END;
+}
+
+bool lv_draw_dispatch_layer(lv_display_t * disp, lv_layer_t * layer)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    /*Remove the finished tasks first*/
+    lv_draw_task_t * t_prev = NULL;
+    lv_draw_task_t * t = layer->draw_task_head;
+    lv_draw_task_t * t_next;
+    bool remove_task = false;
+    while(t) {
+        t_next = t->next;
+        if(t->state == LV_DRAW_TASK_STATE_FINISHED) {
+            cleanup_task(t, disp);
+            remove_task = true;
+            if(t_prev != NULL)
+                t_prev->next = t_next;
+            else
+                layer->draw_task_head = t_next;
+        }
+        else {
+            t_prev = t;
+        }
+        t = t_next;
+    }
+
+    bool task_dispatched = false;
+
+    /*This layer is ready, enable blending its buffer*/
+    if(layer->parent && layer->all_tasks_added && layer->draw_task_head == NULL) {
+        /*Find a draw task with TYPE_LAYER in the layer where the src is this layer*/
+        lv_draw_task_t * t_src = layer->parent->draw_task_head;
+        while(t_src) {
+            if(t_src->type == LV_DRAW_TASK_TYPE_LAYER && t_src->state == LV_DRAW_TASK_STATE_BLOCKED) {
+                lv_draw_image_dsc_t * draw_dsc = t_src->draw_dsc;
+                if(draw_dsc->src == layer) {
+                    t_src->state = LV_DRAW_TASK_STATE_WAITING;
+                    lv_draw_dispatch_request();
+                    break;
+                }
+            }
+            t_src = t_src->next;
+        }
+    }
+    /*Assign draw tasks to the draw_units*/
+    else if(remove_task || layer->draw_task_head) {
+        /*Find a draw unit which is not busy and can take at least one task*/
+        /*Let all draw units to pick draw tasks*/
+        lv_draw_unit_t * u = _draw_info.unit_head;
+        while(u) {
+            LV_PROFILER_DRAW_BEGIN_TAG("dispatch_cb");
+            LV_PROFILER_DRAW_BEGIN_TAG(u->name);
+            int32_t taken_cnt = u->dispatch_cb(u, layer);
+            LV_PROFILER_DRAW_END_TAG(u->name);
+            LV_PROFILER_DRAW_END_TAG("dispatch_cb");
+            if(taken_cnt != LV_DRAW_UNIT_IDLE) task_dispatched = true;
+            u = u->next;
+        }
+    }
+
+    LV_PROFILER_DRAW_END;
+    return task_dispatched;
+}
+
+void lv_draw_dispatch_wait_for_request(void)
+{
+    LV_PROFILER_DRAW_BEGIN;
+#if LV_USE_OS
+    lv_thread_sync_wait(&_draw_info.sync);
+#else
+    while(!_draw_info.dispatch_req);
+    _draw_info.dispatch_req = 0;
+#endif
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_dispatch_request(void)
+{
+    LV_PROFILER_DRAW_BEGIN;
+#if LV_USE_OS
+    lv_thread_sync_signal(&_draw_info.sync);
+#else
+    _draw_info.dispatch_req = 1;
+#endif
+    LV_PROFILER_DRAW_END;
+}
+
+uint32_t lv_draw_get_unit_count(void)
+{
+    return _draw_info.unit_cnt;
+}
+
+lv_draw_task_t * lv_draw_get_available_task(lv_layer_t * layer, lv_draw_task_t * t_prev, uint8_t draw_unit_id)
+{
+    if(_draw_info.unit_cnt == 1) {
+        return get_first_available_task(layer);
+    }
+    else {
+        return lv_draw_get_next_available_task(layer, t_prev, draw_unit_id);
+    }
+}
+
+lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_task_t * t_prev, uint8_t draw_unit_id)
+{
+    LV_PROFILER_DRAW_BEGIN;
+
+    /*If the first task is screen sized, there cannot be independent areas*/
+    if(layer->draw_task_head) {
+        int32_t hor_res = lv_display_get_horizontal_resolution(lv_refr_get_disp_refreshing());
+        int32_t ver_res = lv_display_get_vertical_resolution(lv_refr_get_disp_refreshing());
+        lv_draw_task_t * t = layer->draw_task_head;
+        if(t->state != LV_DRAW_TASK_STATE_WAITING &&
+           t->area.x1 <= 0 && t->area.x2 >= hor_res - 1 &&
+           t->area.y1 <= 0 && t->area.y2 >= ver_res - 1) {
+            LV_PROFILER_DRAW_END;
+            return NULL;
+        }
+    }
+
+    lv_draw_task_t * t = t_prev ? t_prev->next : layer->draw_task_head;
+    while(t) {
+        /*Find a draw task for this draw unit which is waiting and independent?*/
+        if((t->preferred_draw_unit_id == draw_unit_id || t->preferred_draw_unit_id == LV_DRAW_UNIT_NONE) &&
+           t->state == LV_DRAW_TASK_STATE_WAITING &&
+           is_independent(layer, t, draw_unit_id)) {
+            LV_PROFILER_DRAW_END;
+            return t;
+        }
+
+        t = t->next;
+    }
+
+    LV_PROFILER_DRAW_END;
+    return NULL;
+}
+
+uint32_t lv_draw_get_dependent_count(lv_draw_task_t * t_check)
+{
+    if(t_check == NULL) return 0;
+    if(t_check->next == NULL) return 0;
+
+    LV_PROFILER_DRAW_BEGIN;
+    uint32_t cnt = 0;
+
+    lv_draw_task_t * t = t_check->next;
+    while(t) {
+        if((t->state == LV_DRAW_TASK_STATE_WAITING || t->state == LV_DRAW_TASK_STATE_BLOCKED) &&
+           lv_area_is_on(&t_check->area, &t->area)) {
+            cnt++;
+        }
+
+        t = t->next;
+    }
+    LV_PROFILER_DRAW_END;
+    return cnt;
+}
+
+void lv_draw_unit_send_event(const char * name, lv_event_code_t code, void * param)
+{
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_event_t event = { 0 };
+    event.code = code;
+    event.param = param;
+    lv_draw_unit_t * u = _draw_info.unit_head;
+    while(u) {
+        if(u->event_cb && (!name || lv_strcmp(name, u->name) == 0)) {
+            event.current_target = event.original_target = u;
+            LV_PROFILER_DRAW_BEGIN_TAG("event_cb");
+            LV_PROFILER_DRAW_BEGIN_TAG(u->name);
+            u->event_cb(&event);
+            LV_PROFILER_DRAW_END_TAG(u->name);
+            LV_PROFILER_DRAW_END_TAG("event_cb");
+        }
+        u = u->next;
+    }
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_layer_init(lv_layer_t * layer)
+{
+    LV_ASSERT_NULL(layer);
+    lv_memzero(layer, sizeof(lv_layer_t));
+    lv_layer_reset(layer);
+}
+
+void lv_layer_reset(lv_layer_t * layer)
+{
+    LV_ASSERT_NULL(layer);
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    lv_matrix_identity(&layer->matrix);
+#endif
+    layer->opa = LV_OPA_COVER;
+    layer->recolor = lv_color32_make(0, 0, 0, 0);
+}
+
+lv_layer_t * lv_draw_layer_create(lv_layer_t * parent_layer, lv_color_format_t color_format, const lv_area_t * area)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    lv_layer_t * new_layer = lv_malloc_zeroed(sizeof(lv_layer_t));
+    LV_ASSERT_MALLOC(new_layer);
+    if(new_layer == NULL) {
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+
+    lv_draw_layer_init(new_layer, parent_layer, color_format, area);
+
+    /*Inherits transparency from parent*/
+    if(parent_layer) {
+        new_layer->opa = parent_layer->opa;
+        new_layer->recolor = parent_layer->recolor;
+    }
+
+    LV_PROFILER_DRAW_END;
+    return new_layer;
+}
+
+void lv_draw_layer_init(lv_layer_t * layer, lv_layer_t * parent_layer, lv_color_format_t color_format,
+                        const lv_area_t * area)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    lv_layer_init(layer);
+    lv_display_t * disp = lv_refr_get_disp_refreshing();
+
+    layer->parent = parent_layer;
+    layer->_clip_area = *area;
+    layer->buf_area = *area;
+    layer->phy_clip_area = *area;
+    layer->color_format = color_format;
+
+    if(disp->layer_init) disp->layer_init(disp, layer);
+
+    if(disp->layer_head) {
+        lv_layer_t * tail = disp->layer_head;
+        while(tail->next) tail = tail->next;
+        tail->next = layer;
+    }
+    else {
+        disp->layer_head = layer;
+    }
+
+    LV_PROFILER_DRAW_END;
+}
+
+void * lv_draw_layer_alloc_buf(lv_layer_t * layer)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    /*If the buffer of the layer is already allocated return it*/
+    if(layer->draw_buf != NULL) {
+        LV_PROFILER_DRAW_END;
+        return layer->draw_buf->data;
+    }
+
+    /*If the buffer of the layer is not allocated yet, allocate it now*/
+    int32_t w = lv_area_get_width(&layer->buf_area);
+    int32_t h = lv_area_get_height(&layer->buf_area);
+    uint32_t layer_size_byte = h * lv_draw_buf_width_to_stride(w, layer->color_format);
+
+#if LV_DRAW_LAYER_MAX_MEMORY > 0
+    /* Do not allocate the layer if the sum of allocated layer sizes
+     * will exceed `LV_DRAW_LAYER_MAX_MEMORY` */
+    if((_draw_info.used_memory_for_layers + layer_size_byte) > LV_DRAW_LAYER_MAX_MEMORY) {
+        LV_LOG_WARN("LV_DRAW_LAYER_MAX_MEMORY was reached when allocating the layer.");
+        return NULL;
+    }
+#endif
+
+    layer->draw_buf = lv_draw_buf_create(w, h, layer->color_format, 0);
+
+    if(layer->draw_buf == NULL) {
+        LV_LOG_WARN("Allocating layer buffer failed. Try later");
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+
+    _draw_info.used_memory_for_layers += layer_size_byte;
+    LV_LOG_INFO("Layer memory used: %" LV_PRIu32 " kB", get_layer_size_kb(_draw_info.used_memory_for_layers));
+
+    if(lv_color_format_has_alpha(layer->color_format)) {
+        lv_draw_buf_clear(layer->draw_buf, NULL);
+    }
+
+    LV_PROFILER_DRAW_END;
+    return layer->draw_buf->data;
+}
+
+void * lv_draw_layer_go_to_xy(lv_layer_t * layer, int32_t x, int32_t y)
+{
+    return lv_draw_buf_goto_xy(layer->draw_buf, x, y);
+}
+
+lv_draw_task_type_t lv_draw_task_get_type(const lv_draw_task_t * t)
+{
+    return t->type;
+}
+
+void * lv_draw_task_get_draw_dsc(const lv_draw_task_t * t)
+{
+    return t->draw_dsc;
+}
+
+void lv_draw_task_get_area(const lv_draw_task_t * t, lv_area_t * area)
+{
+    *area = t->area;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Check if there are older draw task overlapping the area of `t_check`
+ * @param layer         the draw ctx to search in
+ * @param t_check       check this task if it overlaps with the older ones
+ * @param draw_unit_id  draw unit ID for which the independence check is called
+ * @return              true: `t_check` is not overlapping with older tasks so it's independent
+ */
+static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check, uint8_t draw_unit_id)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_task_t * t = layer->draw_task_head;
+
+    /*If t_check is outside of the older tasks then it's independent*/
+    while(t && t != t_check) {
+        /*It's independent of finished draw tasks, and queued draw tasks of the same draw unit,
+         *so no need to check it*/
+        if(t->state == LV_DRAW_TASK_STATE_FINISHED ||
+           (t->state == LV_DRAW_TASK_STATE_QUEUED && t->preferred_draw_unit_id == draw_unit_id)) {
+            t = t->next;
+            continue;
+        }
+
+        lv_area_t a;
+        if(lv_area_intersect(&a, &t->_real_area, &t_check->_real_area)) {
+            LV_PROFILER_DRAW_END;
+            return false;
+        }
+        t = t->next;
+    }
+    LV_PROFILER_DRAW_END;
+
+    return true;
+}
+
+/**
+ * Get the size of the draw descriptor of a draw task
+ * @param type      type of the draw task
+ * @return          size of the draw descriptor in bytes
+ */
+static inline size_t get_draw_dsc_size(lv_draw_task_type_t type)
+{
+    switch(type) {
+        case LV_DRAW_TASK_TYPE_NONE:
+            return 0;
+        case LV_DRAW_TASK_TYPE_FILL:
+            return sizeof(lv_draw_fill_dsc_t);
+        case LV_DRAW_TASK_TYPE_BORDER:
+            return sizeof(lv_draw_border_dsc_t);
+        case LV_DRAW_TASK_TYPE_BOX_SHADOW:
+            return sizeof(lv_draw_box_shadow_dsc_t);
+        case LV_DRAW_TASK_TYPE_LETTER:
+            return sizeof(lv_draw_letter_dsc_t);
+        case LV_DRAW_TASK_TYPE_LABEL:
+            return sizeof(lv_draw_label_dsc_t);
+        case LV_DRAW_TASK_TYPE_IMAGE:
+            return sizeof(lv_draw_image_dsc_t);
+        case LV_DRAW_TASK_TYPE_LAYER:
+            return sizeof(lv_draw_image_dsc_t);
+        case LV_DRAW_TASK_TYPE_LINE:
+            return sizeof(lv_draw_line_dsc_t);
+        case LV_DRAW_TASK_TYPE_ARC:
+            return sizeof(lv_draw_arc_dsc_t);
+        case LV_DRAW_TASK_TYPE_TRIANGLE:
+            return sizeof(lv_draw_triangle_dsc_t);
+        case LV_DRAW_TASK_TYPE_MASK_RECTANGLE:
+            return sizeof(lv_draw_mask_rect_dsc_t);
+
+        /* no struct match for LV_DRAW_TASK_TYPE_MASK_BITMAP, set it to zero now */
+        case LV_DRAW_TASK_TYPE_MASK_BITMAP:
+            return 0;
+#if LV_USE_VECTOR_GRAPHIC
+        case LV_DRAW_TASK_TYPE_VECTOR:
+            return sizeof(lv_draw_vector_dsc_t);
+#endif
+#if LV_USE_3DTEXTURE
+        case LV_DRAW_TASK_TYPE_3D:
+            return sizeof(lv_draw_3d_dsc_t);
+#endif
+            /* Note that default is not added here because when adding new draw task type,
+             * if forget to add case, the compiler will automatically report a warning.
+             */
+    }
+
+    return 0;
+}
+
+/**
+ * Clean-up resources allocated by a finished task
+ * @param t         pointer to a draw task
+ * @param disp      pointer to a display on which the task was drawn
+ */
+static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    /*If it was layer drawing free the layer too*/
+    if(t->type == LV_DRAW_TASK_TYPE_LAYER) {
+        lv_draw_image_dsc_t * draw_image_dsc = t->draw_dsc;
+        lv_layer_t * layer_drawn = (lv_layer_t *)draw_image_dsc->src;
+
+        if(layer_drawn->draw_buf) {
+            int32_t h = lv_area_get_height(&layer_drawn->buf_area);
+            uint32_t layer_size_byte = h * layer_drawn->draw_buf->header.stride;
+
+            if(_draw_info.used_memory_for_layers >= layer_size_byte) {
+                _draw_info.used_memory_for_layers -= layer_size_byte;
+            }
+            else {
+                _draw_info.used_memory_for_layers = 0;
+                LV_LOG_WARN("More layers were freed than allocated");
+            }
+            LV_LOG_INFO("Layer memory used: %" LV_PRIu32 " kB", get_layer_size_kb(_draw_info.used_memory_for_layers));
+            lv_draw_buf_destroy(layer_drawn->draw_buf);
+            layer_drawn->draw_buf = NULL;
+        }
+
+        /*Remove the layer from  the display's*/
+        if(disp) {
+            lv_layer_t * l2 = disp->layer_head;
+            while(l2) {
+                if(l2->next == layer_drawn) {
+                    l2->next = layer_drawn->next;
+                    break;
+                }
+                l2 = l2->next;
+            }
+
+            if(disp->layer_deinit) {
+                LV_PROFILER_DRAW_BEGIN_TAG("layer_deinit");
+                disp->layer_deinit(disp, layer_drawn);
+                LV_PROFILER_DRAW_END_TAG("layer_deinit");
+            }
+            lv_free(layer_drawn);
+        }
+    }
+    lv_draw_label_dsc_t * draw_label_dsc = lv_draw_task_get_label_dsc(t);
+    if(draw_label_dsc && draw_label_dsc->text_local) {
+        lv_free((void *)draw_label_dsc->text);
+        draw_label_dsc->text = NULL;
+    }
+
+    lv_free(t);
+    LV_PROFILER_DRAW_END;
+}
+
+static lv_draw_task_t * get_first_available_task(lv_layer_t * layer)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    /* If there is only 1 draw unit the task can be consumed linearly as
+     * they are added in the correct order. However, it can happen that
+     * there is a `LV_DRAW_TASK_TYPE_LAYER` which can be blended only when
+     * all its tasks are ready. As other areas might be on top of that
+     * layer-to-blend don't skip it. Instead stop there, so that the
+     * draw tasks of that layer can be consumed and can be finished.
+     * After that this layer-to-blenf will have `LV_DRAW_TASK_STATE_WAITING`
+     * so it can be blended normally.*/
+    lv_draw_task_t * t = layer->draw_task_head;
+    while(t) {
+        /*Not waiting to be rendered, leave this layer while the first task is ready (i.e. not blocked)*/
+        if(t->state != LV_DRAW_TASK_STATE_WAITING) {
+            t = NULL;
+            break;
+        }
+        /*Waiting to be rendered, use it*/
+        else {
+            break;
+        }
+        t = t->next;
+    }
+
+    LV_PROFILER_DRAW_END;
+    return t;
+}

components/easylvgl/lvgl9/src/draw/lv_draw.h

@@ -0,0 +1,365 @@
+/**
+ * @file lv_draw.h
+ *
+ */
+
+/**
+ * Modified by NXP in 2024
+ */
+
+#ifndef LV_DRAW_H
+#define LV_DRAW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#include "../misc/lv_types.h"
+#include "../misc/lv_style.h"
+#include "../misc/lv_text.h"
+#include "../misc/lv_profiler.h"
+#include "../misc/lv_matrix.h"
+#include "../misc/lv_event.h"
+#include "lv_image_decoder.h"
+#include "lv_draw_buf.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_DRAW_UNIT_NONE  0
+#define LV_DRAW_UNIT_IDLE  -1   /**< The draw unit is idle, new dispatching might be requested to try again */
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+#if !LV_USE_MATRIX
+#error "LV_DRAW_TRANSFORM_USE_MATRIX requires LV_USE_MATRIX = 1"
+#endif
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_DRAW_TASK_TYPE_NONE = 0,
+    LV_DRAW_TASK_TYPE_FILL,
+    LV_DRAW_TASK_TYPE_BORDER,
+    LV_DRAW_TASK_TYPE_BOX_SHADOW,
+    LV_DRAW_TASK_TYPE_LETTER,
+    LV_DRAW_TASK_TYPE_LABEL,
+    LV_DRAW_TASK_TYPE_IMAGE,
+    LV_DRAW_TASK_TYPE_LAYER,
+    LV_DRAW_TASK_TYPE_LINE,
+    LV_DRAW_TASK_TYPE_ARC,
+    LV_DRAW_TASK_TYPE_TRIANGLE,
+    LV_DRAW_TASK_TYPE_MASK_RECTANGLE,
+    LV_DRAW_TASK_TYPE_MASK_BITMAP,
+#if LV_USE_VECTOR_GRAPHIC
+    LV_DRAW_TASK_TYPE_VECTOR,
+#endif
+#if LV_USE_3DTEXTURE
+    LV_DRAW_TASK_TYPE_3D,
+#endif
+} lv_draw_task_type_t;
+
+typedef enum {
+    /** Waiting for an other task to be finished.
+     * For example in case of `LV_DRAW_TASK_TYPE_LAYER` (used to blend a layer)
+     * is blocked until all the draw tasks of the layer is rendered. */
+    LV_DRAW_TASK_STATE_BLOCKED,
+
+    /** The draw task is added to the layers list and waits to be rendered. */
+    LV_DRAW_TASK_STATE_WAITING,
+
+    /** The draw task is added to the command queue of the draw unit.
+     * As the queued task are executed in order it's possible to queue multiple draw task
+     * (for the same draw unit) even if they are depending on each other.
+     * Therefore `lv_draw_get_available_task` and `lv_draw_get_next_available_task` can return
+     * draw task for the same draw unit even if a dependent draw task is not finished ready yet.*/
+    LV_DRAW_TASK_STATE_QUEUED,
+
+    /** The draw task is being rendered. This draw task needs to be finished before
+     * `lv_draw_get_available_task` and `lv_draw_get_next_available_task` would
+     * return any depending draw tasks.*/
+    LV_DRAW_TASK_STATE_IN_PROGRESS,
+
+    /** The draw task is rendered. It will be removed from the draw task list of the layer
+     * and freed automatically. */
+    LV_DRAW_TASK_STATE_FINISHED,
+} lv_draw_task_state_t;
+
+struct _lv_layer_t  {
+    /** Target draw buffer of the layer */
+    lv_draw_buf_t * draw_buf;
+
+    /** Linked list of draw tasks */
+    lv_draw_task_t * draw_task_head;
+
+    /** Parent layer */
+    lv_layer_t * parent;
+
+    /** Next layer */
+    lv_layer_t * next;
+
+    /** User data */
+    void * user_data;
+
+    /** The absolute coordinates of the buffer */
+    lv_area_t buf_area;
+
+    /** The physical clipping area relative to the display */
+    lv_area_t phy_clip_area;
+
+    /**
+     * NEVER USE IT DRAW UNITS. USED INTERNALLY DURING DRAW TASK CREATION.
+     * The current clip area with absolute coordinates, always the same or smaller than `buf_area`
+     * Can be set before new draw tasks are added to indicate the clip area of the draw tasks.
+     * Therefore `lv_draw_add_task()` always saves it in the new draw task to know the clip area when the draw task was added.
+     * During drawing the draw units also sees the saved clip_area and should use it during drawing.
+     * During drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.
+     */
+    lv_area_t _clip_area;
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    /** Transform matrix to be applied when rendering the layer */
+    lv_matrix_t matrix;
+#endif
+
+    /** Partial y offset */
+    int32_t partial_y_offset;
+
+    /** Recolor of the layer */
+    lv_color32_t recolor;
+
+    /** The color format of the layer. LV_COLOR_FORMAT_... */
+    lv_color_format_t color_format;
+
+    /** Flag indicating all tasks are added */
+    bool all_tasks_added;
+
+    /** Opacity of the layer */
+    lv_opa_t opa;
+};
+
+typedef struct {
+    /**The widget for which draw descriptor was created */
+    lv_obj_t * obj;
+
+    /**The widget part for which draw descriptor was created */
+    uint32_t part;
+
+    /**A widget type specific ID (e.g. table row index). See the docs of the given widget.*/
+    uint32_t id1;
+
+    /**A widget type specific ID (e.g. table column index). See the docs of the given widget.*/
+    uint32_t id2;
+
+    /**The target layer */
+    lv_layer_t * layer;
+
+    /**Size of the specific draw descriptor into which this base descriptor is embedded*/
+    size_t dsc_size;
+
+    /**Any custom user data*/
+    void * user_data;
+} lv_draw_dsc_base_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Used internally to initialize the drawing module
+ */
+void lv_draw_init(void);
+
+/**
+ * Deinitialize the drawing module
+ */
+void lv_draw_deinit(void);
+
+/**
+ * Allocate a new draw unit with the given size and appends it to the list of draw units
+ * @param size      the size to allocate. E.g. `sizeof(my_draw_unit_t)`,
+ *                  where the first element of `my_draw_unit_t` is `lv_draw_unit_t`.
+ */
+void * lv_draw_create_unit(size_t size);
+
+/**
+ * Add an empty draw task to the draw task list of a layer.
+ * @param layer     pointer to a layer
+ * @param coords    the coordinates of the draw task
+ * @return          the created draw task which needs to be
+ *                  further configured e.g. by added a draw descriptor
+ */
+lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type);
+
+/**
+ * Needs to be called when a draw task is created and configured.
+ * It will send an event about the new draw task to the widget
+ * and assign it to a draw unit.
+ * @param layer     pointer to a layer
+ * @param t         pointer to a draw task
+ */
+void lv_draw_finalize_task_creation(lv_layer_t * layer, lv_draw_task_t * t);
+
+/**
+ * Try dispatching draw tasks to draw units
+ */
+void lv_draw_dispatch(void);
+
+/**
+ * Used internally to try dispatching draw tasks of a specific layer
+ * @param disp      pointer to a display on which the dispatching was requested
+ * @param layer     pointer to a layer
+ * @return          at least one draw task is being rendered (maybe it was taken earlier)
+ */
+bool lv_draw_dispatch_layer(lv_display_t * disp, lv_layer_t * layer);
+
+/**
+ * Wait for a new dispatch request.
+ * It's blocking if `LV_USE_OS == 0` else it yields
+ */
+void lv_draw_dispatch_wait_for_request(void);
+
+/**
+ * Wait for draw finish in case of asynchronous task execution.
+ * If `LV_USE_OS == 0` it just return.
+ */
+void lv_draw_wait_for_finish(void);
+
+/**
+ * When a draw unit finished a draw task it needs to request dispatching
+ * to let LVGL assign a new draw task to it
+ */
+void lv_draw_dispatch_request(void);
+
+/**
+ * Get the total number of draw units.
+  */
+uint32_t lv_draw_get_unit_count(void);
+
+/**
+ * If there is only one draw unit check the first draw task if it's available.
+ * If there are multiple draw units call `lv_draw_get_next_available_task` to find a task.
+ * @param layer             the draw layer to search in
+ * @param t_prev            continue searching from this task
+ * @param draw_unit_id      check the task where `preferred_draw_unit_id` equals this value or `LV_DRAW_UNIT_NONE`
+ * @return                  an available draw task or NULL if there is not any
+ */
+lv_draw_task_t * lv_draw_get_available_task(lv_layer_t * layer, lv_draw_task_t * t_prev, uint8_t draw_unit_id);
+
+/**
+ * Find and available draw task
+ * @param layer             the draw layer to search in
+ * @param t_prev            continue searching from this task
+ * @param draw_unit_id      check the task where `preferred_draw_unit_id` equals this value or `LV_DRAW_UNIT_NONE`
+ * @return                  an available draw task or NULL if there is not any
+ */
+lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_task_t * t_prev, uint8_t draw_unit_id);
+
+/**
+ * Tell how many draw task are waiting to be drawn on the area of `t_check`.
+ * It can be used to determine if a GPU shall combine many draw tasks into one or not.
+ * If a lot of tasks are waiting for the current ones it makes sense to draw them one-by-one
+ * to not block the dependent tasks' rendering
+ * @param t_check   the task whose dependent tasks shall be counted
+ * @return          number of tasks depending on `t_check`
+ */
+uint32_t lv_draw_get_dependent_count(lv_draw_task_t * t_check);
+
+
+/**
+ * Send an event to the draw units
+ * @param name              the name of the draw unit to send the event to
+ * @param code              the event code
+ * @param param             the event parameter
+ */
+void lv_draw_unit_send_event(const char * name, lv_event_code_t code, void * param);
+
+/**
+ * Initialize a layer
+ * @param layer pointer to a layer to initialize
+ */
+void lv_layer_init(lv_layer_t * layer);
+
+/**
+ * Reset the layer to a drawable state
+ * @param layer pointer to a layer to reset
+ */
+void lv_layer_reset(lv_layer_t * layer);
+
+/**
+ * Create (allocate) a new layer on a parent layer
+ * @param parent_layer      the parent layer to which the layer will be merged when it's rendered
+ * @param color_format      the color format of the layer
+ * @param area              the areas of the layer (absolute coordinates)
+ * @return                  the new target_layer or NULL on error
+ */
+lv_layer_t * lv_draw_layer_create(lv_layer_t * parent_layer, lv_color_format_t color_format, const lv_area_t * area);
+
+/**
+ * Initialize a layer which is allocated by the user
+ * @param layer             pointer the layer to initialize (its lifetime needs to be managed by the user)
+ * @param parent_layer      the parent layer to which the layer will be merged when it's rendered
+ * @param color_format      the color format of the layer
+ * @param area              the areas of the layer (absolute coordinates)
+ * @return                  the new target_layer or NULL on error
+ */
+void lv_draw_layer_init(lv_layer_t * layer, lv_layer_t * parent_layer, lv_color_format_t color_format,
+                        const lv_area_t * area);
+
+/**
+ * Try to allocate a buffer for the layer.
+ * @param layer             pointer to a layer
+ * @return                  pointer to the allocated aligned buffer or NULL on failure
+ */
+void * lv_draw_layer_alloc_buf(lv_layer_t * layer);
+
+/**
+ * Got to a pixel at X and Y coordinate on a layer
+ * @param layer             pointer to a layer
+ * @param x                 the target X coordinate
+ * @param y                 the target X coordinate
+ * @return                  `buf` offset to point to the given X and Y coordinate
+ */
+void * lv_draw_layer_go_to_xy(lv_layer_t * layer, int32_t x, int32_t y);
+
+/**
+ * Get the type of a draw task
+ * @param t   the draw task to get the type of
+ * @return    the draw task type
+*/
+lv_draw_task_type_t lv_draw_task_get_type(const lv_draw_task_t * t);
+
+/**
+ * Get the draw descriptor of a draw task
+ * @param t   the draw task to get the draw descriptor of
+ * @return    a void pointer to the draw descriptor
+*/
+void * lv_draw_task_get_draw_dsc(const lv_draw_task_t * t);
+
+/**
+ * Get the draw area of a draw task
+ * @param t      the draw task to get the draw area of
+ * @param area   the destination where the draw area will be stored
+*/
+void lv_draw_task_get_area(const lv_draw_task_t * t, lv_area_t * area);
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_3d.c

@@ -0,0 +1,71 @@
+/**
+ * @file lv_draw_3d.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_3d.h"
+#if LV_USE_3DTEXTURE
+
+#include "lv_draw_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_3d_dsc_init(lv_draw_3d_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_3d_dsc_t));
+    dsc->base.dsc_size = sizeof(lv_draw_3d_dsc_t);
+    dsc->tex_id = LV_3DTEXTURE_ID_NULL;
+    dsc->h_flip = false;
+    dsc->v_flip = false;
+    dsc->opa = LV_OPA_COVER;
+}
+
+lv_draw_3d_dsc_t * lv_draw_task_get_3d_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_3D ? (lv_draw_3d_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_3d(lv_layer_t * layer, const lv_draw_3d_dsc_t * dsc, const lv_area_t * coords)
+{
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_3D);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+
+    LV_PROFILER_DRAW_END;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_3DTEXTURE*/

components/easylvgl/lvgl9/src/draw/lv_draw_3d.h

@@ -0,0 +1,72 @@
+/**
+ * @file lv_draw_3d.h
+ *
+ */
+
+#ifndef LV_DRAW_3D_H
+#define LV_DRAW_3D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../lv_conf_internal.h"
+#if LV_USE_3DTEXTURE
+
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+    lv_3dtexture_id_t tex_id;
+    bool h_flip;
+    bool v_flip;
+    lv_opa_t opa;
+} lv_draw_3d_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a 3D draw descriptor
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_3d_dsc_init(lv_draw_3d_dsc_t * dsc);
+
+/**
+ * Try to get a 3D draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_3D
+ */
+lv_draw_3d_dsc_t * lv_draw_task_get_3d_dsc(lv_draw_task_t * task);
+
+/**
+ * Create a 3D draw task
+ * @param layer     pointer to a layer
+ * @param dsc       pointer to an initialized `lv_draw_3d_dsc_t` variable
+ */
+void lv_draw_3d(lv_layer_t * layer, const lv_draw_3d_dsc_t * dsc, const lv_area_t * coords);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_3DTEXTURE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_3D_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_arc.c

@@ -0,0 +1,172 @@
+/**
+ * @file lv_draw_arc.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_private.h"
+#include "../core/lv_obj.h"
+#include "lv_draw_arc.h"
+#include "../core/lv_obj_event.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_arc_dsc_t));
+    dsc->width = 1;
+    dsc->opa = LV_OPA_COVER;
+    dsc->color = lv_color_black();
+    dsc->base.dsc_size = sizeof(lv_draw_arc_dsc_t);
+}
+
+lv_draw_arc_dsc_t * lv_draw_task_get_arc_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_ARC ? (lv_draw_arc_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_arc(lv_layer_t * layer, const lv_draw_arc_dsc_t * dsc)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->width == 0) return;
+    if(dsc->start_angle == dsc->end_angle) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_area_t a;
+    a.x1 = dsc->center.x - dsc->radius;
+    a.y1 = dsc->center.y - dsc->radius;
+    a.x2 = dsc->center.x + dsc->radius - 1;
+    a.y2 = dsc->center.y + dsc->radius - 1;
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_ARC);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_arc_get_area(int32_t x, int32_t y, uint16_t radius,  lv_value_precise_t start_angle,
+                          lv_value_precise_t end_angle,
+                          int32_t w, bool rounded, lv_area_t * area)
+{
+    int32_t rout = radius;
+    int32_t start_angle_int = (int32_t) start_angle;
+    int32_t end_angle_int = (int32_t) end_angle;
+
+    /*Special case: full arc invalidation */
+    if(end_angle_int == start_angle_int + 360) {
+        area->x1 = x - rout;
+        area->y1 = y - rout;
+        area->x2 = x + rout;
+        area->y2 = y + rout;
+        return;
+    }
+
+    if(start_angle_int > 360) start_angle_int -= 360;
+    if(end_angle_int > 360) end_angle_int -= 360;
+
+    int32_t rin = radius - w;
+    int32_t extra_area = rounded ? w / 2 + 1 : 0;
+    uint8_t start_quarter = start_angle_int / 90;
+    uint8_t end_quarter = end_angle_int / 90;
+
+    /*360 deg still counts as quarter 3 (360 / 90 would be 4)*/
+    if(start_quarter == 4) start_quarter = 3;
+    if(end_quarter == 4) end_quarter = 3;
+
+    if(start_quarter == end_quarter && start_angle_int <= end_angle_int) {
+        if(start_quarter == 0) {
+            area->y1 = y + ((lv_trigo_sin(start_angle_int) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+            area->x2 = x + ((lv_trigo_sin(start_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+
+            area->y2 = y + ((lv_trigo_sin(end_angle_int) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+            area->x1 = x + ((lv_trigo_sin(end_angle_int + 90) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+        }
+        else if(start_quarter == 1) {
+            area->y2 = y + ((lv_trigo_sin(start_angle_int) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+            area->x2 = x + ((lv_trigo_sin(start_angle_int + 90) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+
+            area->y1 = y + ((lv_trigo_sin(end_angle_int) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+            area->x1 = x + ((lv_trigo_sin(end_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+        }
+        else if(start_quarter == 2) {
+            area->x1 = x + ((lv_trigo_sin(start_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+            area->y2 = y + ((lv_trigo_sin(start_angle_int) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+
+            area->y1 = y + ((lv_trigo_sin(end_angle_int) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+            area->x2 = x + ((lv_trigo_sin(end_angle_int + 90) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+        }
+        else if(start_quarter == 3) {
+            area->x1 = x + ((lv_trigo_sin(start_angle_int + 90) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+            area->y1 = y + ((lv_trigo_sin(start_angle_int) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+
+            area->x2 = x + ((lv_trigo_sin(end_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+            area->y2 = y + ((lv_trigo_sin(end_angle_int) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+        }
+    }
+    else if(start_quarter == 0 && end_quarter == 1) {
+        area->x1 = x + ((lv_trigo_sin(end_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+        area->y1 = y + ((LV_MIN(lv_trigo_sin(end_angle_int),
+                                lv_trigo_sin(start_angle_int))  * rin) >> LV_TRIGO_SHIFT) - extra_area;
+        area->x2 = x + ((lv_trigo_sin(start_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+        area->y2 = y + rout + extra_area;
+    }
+    else if(start_quarter == 1 && end_quarter == 2) {
+        area->x1 = x - rout - extra_area;
+        area->y1 = y + ((lv_trigo_sin(end_angle_int) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+        area->x2 = x + ((LV_MAX(lv_trigo_sin(start_angle_int + 90),
+                                lv_trigo_sin(end_angle_int + 90)) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+        area->y2 = y + ((lv_trigo_sin(start_angle_int) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+    }
+    else if(start_quarter == 2 && end_quarter == 3) {
+        area->x1 = x + ((lv_trigo_sin(start_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+        area->y1 = y - rout - extra_area;
+        area->x2 = x + ((lv_trigo_sin(end_angle_int + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+        area->y2 = y + (LV_MAX(lv_trigo_sin(end_angle_int) * rin,
+                               lv_trigo_sin(start_angle_int) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+    }
+    else if(start_quarter == 3 && end_quarter == 0) {
+        area->x1 = x + ((LV_MIN(lv_trigo_sin(end_angle_int + 90),
+                                lv_trigo_sin(start_angle_int + 90)) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+        area->y1 = y + ((lv_trigo_sin(start_angle_int) * rout) >> LV_TRIGO_SHIFT) - extra_area;
+        area->x2 = x + rout + extra_area;
+        area->y2 = y + ((lv_trigo_sin(end_angle_int) * rout) >> LV_TRIGO_SHIFT) + extra_area;
+
+    }
+    else {
+        area->x1 = x - rout;
+        area->y1 = y - rout;
+        area->x2 = x + rout;
+        area->y2 = y + rout;
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

components/easylvgl/lvgl9/src/draw/lv_draw_arc.h

@@ -0,0 +1,109 @@
+/**
+ * @file lv_draw_arc.h
+ *
+ */
+
+#ifndef LV_DRAW_ARC_H
+#define LV_DRAW_ARC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**The color of the arc*/
+    lv_color_t color;
+
+    /**The width (thickness) of the arc */
+    int32_t width;
+
+    /**The start angle in 1 degree units (if `LV_USE_FLOAT` is enabled a float number can be also used)
+     * 0° is the 3 o'clock position, 90° is the 6 o'clock, etc. */
+    lv_value_precise_t start_angle;
+
+    /**The end angle, similarly to start_angle. */
+    lv_value_precise_t end_angle;
+
+    /**The center point of the arc. */
+    lv_point_t center;
+
+    /**An image source to be used instead of `color`. `NULL` if unused*/
+    const void * img_src;
+
+    /**The outer radius of the arc*/
+    uint16_t radius;
+
+    /**Opacity of the arc in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**1: Make the arc ends rounded*/
+    uint8_t rounded : 1;
+} lv_draw_arc_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize an arc draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc);
+
+/**
+ * Try to get an arc draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_ARC
+ */
+lv_draw_arc_dsc_t * lv_draw_task_get_arc_dsc(lv_draw_task_t * task);
+
+/**
+ * Create an arc draw task.
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor variable
+ */
+void lv_draw_arc(lv_layer_t * layer, const lv_draw_arc_dsc_t * dsc);
+
+/**
+ * Get an area the should be invalidated when the arcs angle changed between start_angle and end_ange
+ * @param x             the x coordinate of the center of the arc
+ * @param y             the y coordinate of the center of the arc
+ * @param radius        the radius of the arc
+ * @param start_angle   the start angle of the arc (0 deg on the bottom, 90 deg on the right)
+ * @param end_angle     the end angle of the arc
+ * @param w             width of the arc
+ * @param rounded       true: the arc is rounded
+ * @param area          store the area to invalidate here
+ */
+void lv_draw_arc_get_area(int32_t x, int32_t y, uint16_t radius,  lv_value_precise_t start_angle,
+                          lv_value_precise_t end_angle,
+                          int32_t w, bool rounded, lv_area_t * area);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_ARC_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_buf.c

@@ -0,0 +1,687 @@
+/**
+ * @file lv_draw_buf.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_buf_private.h"
+#include "../misc/lv_types.h"
+#include "../stdlib/lv_string.h"
+#include "../core/lv_global.h"
+#include "../misc/lv_math.h"
+#include "../misc/lv_area_private.h"
+#include "convert/lv_draw_buf_convert.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define default_handlers LV_GLOBAL_DEFAULT()->draw_buf_handlers
+#define font_draw_buf_handlers LV_GLOBAL_DEFAULT()->font_draw_buf_handlers
+#define image_cache_draw_buf_handlers LV_GLOBAL_DEFAULT()->image_cache_draw_buf_handlers
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void * buf_malloc(size_t size, lv_color_format_t color_format);
+static void buf_free(void * buf);
+static void buf_copy(lv_draw_buf_t * dest, const lv_area_t * dest_area,
+                     const lv_draw_buf_t * src, const lv_area_t * src_area);
+static void * buf_align(void * buf, lv_color_format_t color_format);
+static void * draw_buf_malloc(const lv_draw_buf_handlers_t * handler, size_t size_bytes,
+                              lv_color_format_t color_format);
+static void draw_buf_free(const lv_draw_buf_handlers_t * handler, void * buf);
+static uint32_t width_to_stride(uint32_t w, lv_color_format_t color_format);
+static uint32_t _calculate_draw_buf_size(uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride);
+static void draw_buf_get_full_area(const lv_draw_buf_t * draw_buf, lv_area_t * full_area);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_buf_init_handlers(void)
+{
+    lv_draw_buf_init_with_default_handlers(&default_handlers);
+    lv_draw_buf_init_with_default_handlers(&font_draw_buf_handlers);
+    lv_draw_buf_init_with_default_handlers(&image_cache_draw_buf_handlers);
+}
+
+void lv_draw_buf_init_with_default_handlers(lv_draw_buf_handlers_t * handlers)
+{
+    lv_draw_buf_handlers_init(handlers, buf_malloc, buf_free, buf_copy, buf_align, NULL, NULL, width_to_stride);
+}
+
+void lv_draw_buf_handlers_init(lv_draw_buf_handlers_t * handlers,
+                               lv_draw_buf_malloc_cb_t buf_malloc_cb,
+                               lv_draw_buf_free_cb_t buf_free_cb,
+                               lv_draw_buf_copy_cb_t buf_copy_cb,
+                               lv_draw_buf_align_cb_t align_pointer_cb,
+                               lv_draw_buf_cache_operation_cb_t invalidate_cache_cb,
+                               lv_draw_buf_cache_operation_cb_t flush_cache_cb,
+                               lv_draw_buf_width_to_stride_cb_t width_to_stride_cb)
+{
+    lv_memzero(handlers, sizeof(lv_draw_buf_handlers_t));
+    handlers->buf_malloc_cb = buf_malloc_cb;
+    handlers->buf_free_cb = buf_free_cb;
+    handlers->buf_copy_cb = buf_copy_cb;
+    handlers->align_pointer_cb = align_pointer_cb;
+    handlers->invalidate_cache_cb = invalidate_cache_cb;
+    handlers->flush_cache_cb = flush_cache_cb;
+    handlers->width_to_stride_cb = width_to_stride_cb;
+}
+
+lv_draw_buf_handlers_t * lv_draw_buf_get_handlers(void)
+{
+    return &default_handlers;
+}
+
+lv_draw_buf_handlers_t * lv_draw_buf_get_font_handlers(void)
+{
+    return &font_draw_buf_handlers;
+}
+
+lv_draw_buf_handlers_t * lv_draw_buf_get_image_handlers(void)
+{
+    return &image_cache_draw_buf_handlers;
+}
+
+uint32_t lv_draw_buf_width_to_stride(uint32_t w, lv_color_format_t color_format)
+{
+    return lv_draw_buf_width_to_stride_ex(&default_handlers, w, color_format);
+}
+
+uint32_t lv_draw_buf_width_to_stride_ex(const lv_draw_buf_handlers_t * handlers, uint32_t w,
+                                        lv_color_format_t color_format)
+{
+    if(handlers->width_to_stride_cb) return handlers->width_to_stride_cb(w, color_format);
+    else return 0;
+}
+
+void * lv_draw_buf_align(void * data, lv_color_format_t color_format)
+{
+    return lv_draw_buf_align_ex(&default_handlers, data, color_format);
+}
+
+void * lv_draw_buf_align_ex(const lv_draw_buf_handlers_t * handlers, void * data, lv_color_format_t color_format)
+{
+    if(handlers->align_pointer_cb) return handlers->align_pointer_cb(data, color_format);
+    else return NULL;
+}
+
+void lv_draw_buf_invalidate_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area)
+{
+    LV_ASSERT_NULL(draw_buf);
+    LV_ASSERT_NULL(draw_buf->handlers);
+
+    const lv_draw_buf_handlers_t * handlers = draw_buf->handlers;
+    if(!handlers->invalidate_cache_cb) {
+        return;
+    }
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_area_t full;
+    if(area == NULL) {
+        draw_buf_get_full_area(draw_buf, &full);
+        area = &full;
+    }
+
+    handlers->invalidate_cache_cb(draw_buf, area);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_buf_flush_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area)
+{
+    LV_ASSERT_NULL(draw_buf);
+    LV_ASSERT_NULL(draw_buf->handlers);
+
+    const lv_draw_buf_handlers_t * handlers = draw_buf->handlers;
+    if(!handlers->flush_cache_cb) {
+        return;
+    }
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_area_t full;
+    if(area == NULL) {
+        draw_buf_get_full_area(draw_buf, &full);
+        area = &full;
+    }
+
+    handlers->flush_cache_cb(draw_buf, area);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_buf_clear(lv_draw_buf_t * draw_buf, const lv_area_t * a)
+{
+    LV_ASSERT_NULL(draw_buf);
+    LV_PROFILER_DRAW_BEGIN;
+
+    const lv_image_header_t * header = &draw_buf->header;
+    uint32_t stride = header->stride;
+
+    if(a == NULL) {
+        uint8_t * buf = lv_draw_buf_goto_xy(draw_buf, 0, 0);
+        lv_memzero(buf, header->h * stride);
+        lv_draw_buf_flush_cache(draw_buf, a);
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    lv_area_t a_draw_buf;
+    a_draw_buf.x1 = 0;
+    a_draw_buf.y1 = 0;
+    a_draw_buf.x2 = draw_buf->header.w - 1;
+    a_draw_buf.y2 = draw_buf->header.h - 1;
+
+    lv_area_t a_clipped;
+    if(!lv_area_intersect(&a_clipped, a, &a_draw_buf)) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    if(lv_area_get_width(&a_clipped) <= 0) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    if(lv_area_get_height(&a_clipped) <= 0) {
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    uint8_t * buf = lv_draw_buf_goto_xy(draw_buf, a_clipped.x1, a_clipped.y1);
+    uint8_t bpp = lv_color_format_get_bpp(header->cf);
+    uint32_t line_length = (lv_area_get_width(&a_clipped) * bpp + 7) >> 3;
+    int32_t y;
+    for(y = a_clipped.y1; y <= a_clipped.y2; y++) {
+        lv_memzero(buf, line_length);
+        buf += stride;
+    }
+    lv_draw_buf_flush_cache(draw_buf, a);
+    LV_PROFILER_DRAW_END;
+}
+
+lv_result_t lv_draw_buf_init(lv_draw_buf_t * draw_buf, uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride,
+                             void * data, uint32_t data_size)
+{
+    LV_ASSERT_NULL(draw_buf);
+    if(draw_buf == NULL) return LV_RESULT_INVALID;
+
+    lv_memzero(draw_buf, sizeof(lv_draw_buf_t));
+    if(stride == 0) stride = lv_draw_buf_width_to_stride(w, cf);
+    if(stride * h > data_size) {
+        LV_LOG_WARN("Data size too small, required: %" LV_PRId32 ", provided: %" LV_PRId32, stride * h,
+                    data_size);
+        return LV_RESULT_INVALID;
+    }
+
+    lv_image_header_t * header = &draw_buf->header;
+    header->w = w;
+    header->h = h;
+    header->cf = cf;
+    header->stride = stride;
+    header->flags = 0;
+    header->magic = LV_IMAGE_HEADER_MAGIC;
+
+    draw_buf->data = data;
+    draw_buf->unaligned_data = data;
+    draw_buf->handlers = &default_handlers;
+    draw_buf->data_size = data_size;
+    if(lv_draw_buf_align(data, cf) != draw_buf->unaligned_data) {
+        LV_LOG_WARN("Data is not aligned, ignored");
+    }
+    return LV_RESULT_OK;
+}
+
+lv_draw_buf_t * lv_draw_buf_create(uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride)
+{
+    return lv_draw_buf_create_ex(&default_handlers, w, h, cf, stride);
+}
+
+lv_draw_buf_t * lv_draw_buf_create_ex(const lv_draw_buf_handlers_t * handlers, uint32_t w, uint32_t h,
+                                      lv_color_format_t cf, uint32_t stride)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_buf_t * draw_buf = lv_malloc_zeroed(sizeof(lv_draw_buf_t));
+    LV_ASSERT_MALLOC(draw_buf);
+    if(draw_buf == NULL) {
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+    if(stride == 0) stride = lv_draw_buf_width_to_stride(w, cf);
+
+    uint32_t size = _calculate_draw_buf_size(w, h, cf, stride);
+
+    void * buf = draw_buf_malloc(handlers, size, cf);
+    /*Do not assert here as LVGL or the app might just want to try creating a draw_buf*/
+    if(buf == NULL) {
+        LV_LOG_WARN("No memory: %"LV_PRIu32"x%"LV_PRIu32", cf: %d, stride: %"LV_PRIu32", %"LV_PRIu32"Byte, ",
+                    w, h, cf, stride, size);
+        lv_free(draw_buf);
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+
+    draw_buf->header.w = w;
+    draw_buf->header.h = h;
+    draw_buf->header.cf = cf;
+    draw_buf->header.flags = LV_IMAGE_FLAGS_MODIFIABLE | LV_IMAGE_FLAGS_ALLOCATED;
+    draw_buf->header.stride = stride;
+    draw_buf->header.magic = LV_IMAGE_HEADER_MAGIC;
+    draw_buf->data = lv_draw_buf_align(buf, cf);
+    draw_buf->unaligned_data = buf;
+    draw_buf->data_size = size;
+    draw_buf->handlers = handlers;
+    LV_PROFILER_DRAW_END;
+    return draw_buf;
+}
+
+lv_draw_buf_t * lv_draw_buf_dup(const lv_draw_buf_t * draw_buf)
+{
+    return lv_draw_buf_dup_ex(&default_handlers, draw_buf);
+}
+
+lv_draw_buf_t * lv_draw_buf_dup_ex(const lv_draw_buf_handlers_t * handlers, const lv_draw_buf_t * draw_buf)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    const lv_image_header_t * header = &draw_buf->header;
+    lv_draw_buf_t * new_buf = lv_draw_buf_create_ex(handlers, header->w, header->h, header->cf, header->stride);
+    if(new_buf == NULL) {
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+
+    new_buf->header.flags = draw_buf->header.flags;
+    new_buf->header.flags |= LV_IMAGE_FLAGS_MODIFIABLE | LV_IMAGE_FLAGS_ALLOCATED;
+
+    /*Choose the smaller size to copy*/
+    uint32_t size = LV_MIN(draw_buf->data_size, new_buf->data_size);
+
+    /*Copy image data*/
+    lv_memcpy(new_buf->data, draw_buf->data, size);
+    LV_PROFILER_DRAW_END;
+    return new_buf;
+}
+
+lv_draw_buf_t * lv_draw_buf_reshape(lv_draw_buf_t * draw_buf, lv_color_format_t cf, uint32_t w, uint32_t h,
+                                    uint32_t stride)
+{
+    if(draw_buf == NULL) return NULL;
+    LV_PROFILER_DRAW_BEGIN;
+
+    /*If color format is unknown, keep using the original color format.*/
+    if(cf == LV_COLOR_FORMAT_UNKNOWN) cf = draw_buf->header.cf;
+    if(stride == 0) stride = lv_draw_buf_width_to_stride(w, cf);
+
+    uint32_t size = _calculate_draw_buf_size(w, h, cf, stride);
+
+    if(size > draw_buf->data_size) {
+        LV_LOG_TRACE("Draw buf too small for new shape");
+        LV_PROFILER_DRAW_END;
+        return NULL;
+    }
+
+    draw_buf->header.cf = cf;
+    draw_buf->header.w = w;
+    draw_buf->header.h = h;
+    draw_buf->header.stride = stride;
+
+    LV_PROFILER_DRAW_END;
+    return draw_buf;
+}
+
+void lv_draw_buf_destroy(lv_draw_buf_t * draw_buf)
+{
+    LV_ASSERT_NULL(draw_buf);
+    if(draw_buf == NULL) return;
+    LV_PROFILER_DRAW_BEGIN;
+
+    if(draw_buf->header.flags & LV_IMAGE_FLAGS_ALLOCATED) {
+        LV_ASSERT_NULL(draw_buf->handlers);
+
+        const lv_draw_buf_handlers_t * handlers = draw_buf->handlers;
+        draw_buf_free(handlers, draw_buf->unaligned_data);
+        lv_free(draw_buf);
+    }
+    else {
+        LV_LOG_ERROR("draw buffer is not allocated, ignored");
+    }
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_buf_copy(lv_draw_buf_t * dest, const lv_area_t * dest_area,
+                      const lv_draw_buf_t * src, const lv_area_t * src_area)
+{
+    LV_ASSERT_NULL(dest);
+    LV_ASSERT_NULL(dest->handlers);
+    LV_ASSERT_NULL(dest->handlers->buf_copy_cb);
+    LV_ASSERT_NULL(src);
+
+    dest->handlers->buf_copy_cb(dest, dest_area, src, src_area);
+}
+
+void * lv_draw_buf_goto_xy(const lv_draw_buf_t * buf, uint32_t x, uint32_t y)
+{
+    LV_ASSERT_NULL(buf);
+    if(buf == NULL) return NULL;
+
+    if(x >= buf->header.w || y >= buf->header.h) {
+        LV_LOG_ERROR("coordinates out of range, x: %" LV_PRIu32 ", y: %"LV_PRIu32", w: %"LV_PRIu32", h: %"LV_PRIu32, x, y,
+                     (uint32_t)buf->header.w, (uint32_t)buf->header.h);
+        return NULL;
+    }
+
+    uint8_t * data = buf->data;
+
+    /*Skip palette*/
+    data += LV_COLOR_INDEXED_PALETTE_SIZE(buf->header.cf) * sizeof(lv_color32_t);
+    data += buf->header.stride * y;
+
+    if(x == 0) return data;
+
+    return data + x * lv_color_format_get_bpp(buf->header.cf) / 8;
+}
+
+lv_result_t lv_draw_buf_adjust_stride(lv_draw_buf_t * src, uint32_t stride)
+{
+    LV_ASSERT_NULL(src);
+    LV_ASSERT_NULL(src->data);
+    if(src == NULL) return LV_RESULT_INVALID;
+    if(src->data == NULL) return LV_RESULT_INVALID;
+    LV_PROFILER_DRAW_BEGIN;
+
+    const lv_image_header_t * header = &src->header;
+    uint32_t w = header->w;
+    uint32_t h = header->h;
+
+    if(!lv_draw_buf_has_flag(src, LV_IMAGE_FLAGS_MODIFIABLE)) {
+        LV_PROFILER_DRAW_END;
+        return LV_RESULT_INVALID;
+    }
+
+    /*Use global stride*/
+    if(stride == 0) stride = lv_draw_buf_width_to_stride(w, header->cf);
+
+    /*Check if stride already match*/
+    if(header->stride == stride) {
+        LV_PROFILER_DRAW_END;
+        return LV_RESULT_OK;
+    }
+
+    /*Calculate the minimal stride allowed from bpp*/
+    uint32_t bpp = lv_color_format_get_bpp(header->cf);
+    uint32_t min_stride = (w * bpp + 7) >> 3;
+    if(stride < min_stride) {
+        LV_LOG_WARN("New stride is too small. min: %" LV_PRId32, min_stride);
+        LV_PROFILER_DRAW_END;
+        return LV_RESULT_INVALID;
+    }
+
+    /*Check if buffer has enough space. */
+    uint32_t new_size = _calculate_draw_buf_size(w, h, header->cf, stride);
+    if(new_size > src->data_size) {
+        LV_PROFILER_DRAW_END;
+        return LV_RESULT_INVALID;
+    }
+
+    uint32_t offset = LV_COLOR_INDEXED_PALETTE_SIZE(header->cf) * 4;
+
+    if(stride > header->stride) {
+        /*Copy from the last line to the first*/
+        uint8_t * src_data = src->data + offset + header->stride * (h - 1);
+        uint8_t * dst_data = src->data + offset + stride * (h - 1);
+        for(uint32_t y = 0; y < h; y++) {
+            lv_memmove(dst_data, src_data, min_stride);
+            src_data -= header->stride;
+            dst_data -= stride;
+        }
+    }
+    else {
+        /*Copy from the first line to the last*/
+        uint8_t * src_data = src->data + offset;
+        uint8_t * dst_data = src->data + offset;
+        for(uint32_t y = 0; y < h; y++) {
+            lv_memmove(dst_data, src_data, min_stride);
+            src_data += header->stride;
+            dst_data += stride;
+        }
+    }
+
+    src->header.stride = stride;
+
+    LV_PROFILER_DRAW_END;
+    return LV_RESULT_OK;
+}
+
+lv_result_t lv_draw_buf_premultiply(lv_draw_buf_t * draw_buf)
+{
+    LV_ASSERT_NULL(draw_buf);
+    if(draw_buf == NULL) return LV_RESULT_INVALID;
+
+    if(draw_buf->header.flags & LV_IMAGE_FLAGS_PREMULTIPLIED) return LV_RESULT_INVALID;
+    if((draw_buf->header.flags & LV_IMAGE_FLAGS_MODIFIABLE) == 0) {
+        LV_LOG_WARN("draw buf is not modifiable: 0x%04x", draw_buf->header.flags);
+        return LV_RESULT_INVALID;
+    }
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_draw_buf_convert_premultiply(draw_buf);
+
+    draw_buf->header.flags |= LV_IMAGE_FLAGS_PREMULTIPLIED;
+
+    LV_PROFILER_DRAW_END;
+    return LV_RESULT_OK;
+}
+
+void lv_draw_buf_set_palette(lv_draw_buf_t * draw_buf, uint8_t index, lv_color32_t color)
+{
+    LV_ASSERT_NULL(draw_buf);
+    if(draw_buf == NULL) return;
+
+    if(!LV_COLOR_FORMAT_IS_INDEXED(draw_buf->header.cf)) {
+        LV_LOG_WARN("Not indexed color format");
+        return;
+    }
+
+    lv_color32_t * palette = (lv_color32_t *)draw_buf->data;
+    palette[index] = color;
+}
+
+bool lv_draw_buf_has_flag(const lv_draw_buf_t * draw_buf, lv_image_flags_t flag)
+{
+    return draw_buf->header.flags & flag;
+}
+
+void lv_draw_buf_set_flag(lv_draw_buf_t * draw_buf, lv_image_flags_t flag)
+{
+    draw_buf->header.flags |= flag;
+}
+
+void lv_draw_buf_clear_flag(lv_draw_buf_t * draw_buf, lv_image_flags_t flag)
+{
+    draw_buf->header.flags &= ~flag;
+}
+
+lv_result_t lv_draw_buf_from_image(lv_draw_buf_t * buf, const lv_image_dsc_t * img)
+{
+    const lv_result_t res = lv_draw_buf_init(buf, img->header.w, img->header.h, img->header.cf, img->header.stride,
+                                             (void *)img->data, img->data_size);
+    if(res != LV_RESULT_OK) {
+        return res;
+    }
+
+    buf->header.flags = img->header.flags;
+    return res;
+}
+
+void lv_draw_buf_to_image(const lv_draw_buf_t * buf, lv_image_dsc_t * img)
+{
+    lv_memcpy((void *)img, buf, sizeof(lv_image_dsc_t));
+}
+
+void lv_image_buf_set_palette(lv_image_dsc_t * dsc, uint8_t id, lv_color32_t c)
+{
+    LV_LOG_WARN("Deprecated API, use lv_draw_buf_set_palette instead.");
+    lv_draw_buf_set_palette((lv_draw_buf_t *)dsc, id, c);
+}
+
+void lv_image_buf_free(lv_image_dsc_t * dsc)
+{
+    LV_LOG_WARN("Deprecated API, use lv_draw_buf_destroy instead.");
+    if(dsc != NULL) {
+        if(dsc->data != NULL)
+            lv_free((void *)dsc->data);
+
+        lv_free((void *)dsc);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void * buf_malloc(size_t size_bytes, lv_color_format_t color_format)
+{
+    LV_UNUSED(color_format);
+
+    /*Allocate larger memory to be sure it can be aligned as needed*/
+    size_bytes += LV_DRAW_BUF_ALIGN - 1;
+    return lv_malloc(size_bytes);
+}
+
+static void buf_free(void * buf)
+{
+    lv_free(buf);
+}
+
+static void buf_copy(lv_draw_buf_t * dest, const lv_area_t * dest_area,
+                     const lv_draw_buf_t * src, const lv_area_t * src_area)
+{
+    LV_PROFILER_DRAW_BEGIN;
+    uint8_t * dest_bufc;
+    uint8_t * src_bufc;
+    int32_t line_width;
+
+    /*Source and dest color format must be same. Color conversion is not supported yet.*/
+    LV_ASSERT_FORMAT_MSG(dest->header.cf == src->header.cf, "Color format mismatch: %d != %d",
+                         dest->header.cf, src->header.cf);
+
+    if(dest_area == NULL) line_width = dest->header.w;
+    else line_width = lv_area_get_width(dest_area);
+
+    /* For indexed image, copy the palette if we are copying full image area*/
+    if(dest_area == NULL || src_area == NULL) {
+        if(LV_COLOR_FORMAT_IS_INDEXED(dest->header.cf)) {
+            lv_memcpy(dest->data, src->data, LV_COLOR_INDEXED_PALETTE_SIZE(dest->header.cf) * sizeof(lv_color32_t));
+        }
+    }
+
+    /*Check source and dest area have same width*/
+    if((src_area == NULL && line_width != src->header.w) || \
+       (src_area != NULL && line_width != lv_area_get_width(src_area))) {
+        LV_ASSERT_MSG(0, "Source and destination areas have different width");
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    if(src_area) src_bufc = lv_draw_buf_goto_xy(src, src_area->x1, src_area->y1);
+    else src_bufc = lv_draw_buf_goto_xy(src, 0, 0);
+
+    if(dest_area) dest_bufc = lv_draw_buf_goto_xy(dest, dest_area->x1, dest_area->y1);
+    else dest_bufc = lv_draw_buf_goto_xy(dest, 0, 0);
+
+    int32_t start_y, end_y;
+    if(dest_area) {
+        start_y = dest_area->y1;
+        end_y = dest_area->y2;
+    }
+    else {
+        start_y = 0;
+        end_y = dest->header.h - 1;
+    }
+
+    uint32_t dest_stride = dest->header.stride;
+    uint32_t src_stride = src->header.stride;
+    uint32_t line_bytes = (line_width * lv_color_format_get_bpp(dest->header.cf) + 7) >> 3;
+
+    for(; start_y <= end_y; start_y++) {
+        lv_memcpy(dest_bufc, src_bufc, line_bytes);
+        dest_bufc += dest_stride;
+        src_bufc += src_stride;
+    }
+    LV_PROFILER_DRAW_END;
+}
+
+static void * buf_align(void * buf, lv_color_format_t color_format)
+{
+    LV_UNUSED(color_format);
+
+    uint8_t * buf_u8 = buf;
+    if(buf_u8) {
+        buf_u8 = (uint8_t *)LV_ROUND_UP((lv_uintptr_t)buf_u8, LV_DRAW_BUF_ALIGN);
+    }
+    return buf_u8;
+}
+
+static uint32_t width_to_stride(uint32_t w, lv_color_format_t color_format)
+{
+    uint32_t width_byte;
+    width_byte = w * lv_color_format_get_bpp(color_format);
+    width_byte = (width_byte + 7) >> 3; /*Round up*/
+
+    return LV_ROUND_UP(width_byte, LV_DRAW_BUF_STRIDE_ALIGN);
+}
+
+static void * draw_buf_malloc(const lv_draw_buf_handlers_t * handlers, size_t size_bytes,
+                              lv_color_format_t color_format)
+{
+    if(handlers->buf_malloc_cb) return handlers->buf_malloc_cb(size_bytes, color_format);
+    else return NULL;
+}
+
+static void draw_buf_free(const lv_draw_buf_handlers_t * handlers, void * buf)
+{
+    if(handlers->buf_free_cb)
+        handlers->buf_free_cb(buf);
+}
+
+/**
+ * For given width, height, color format, and stride, calculate the size needed for a new draw buffer.
+ */
+static uint32_t _calculate_draw_buf_size(uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride)
+{
+    uint32_t size;
+
+    if(stride == 0) stride = lv_draw_buf_width_to_stride(w, cf);
+
+    size = stride * h;
+    if(cf == LV_COLOR_FORMAT_RGB565A8) {
+        size += (stride / 2) * h; /*A8 mask*/
+    }
+    else if(LV_COLOR_FORMAT_IS_INDEXED(cf)) {
+        /*@todo we have to include palette right before image data*/
+        size += LV_COLOR_INDEXED_PALETTE_SIZE(cf) * 4;
+    }
+
+    return size;
+}
+
+static void draw_buf_get_full_area(const lv_draw_buf_t * draw_buf, lv_area_t * full_area)
+{
+    const lv_image_header_t * header = &draw_buf->header;
+    lv_area_set(full_area, 0, 0, header->w - 1, header->h - 1);
+}

components/easylvgl/lvgl9/src/draw/lv_draw_buf.h

@@ -0,0 +1,363 @@
+/**
+ * @file lv_draw_buf.h
+ *
+ */
+
+#ifndef LV_DRAW_BUF_H
+#define LV_DRAW_BUF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_types.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_color.h"
+#include "../stdlib/lv_string.h"
+#include "lv_image_dsc.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/** Use this value to let LVGL calculate stride automatically */
+#define LV_STRIDE_AUTO 0
+LV_EXPORT_CONST_INT(LV_STRIDE_AUTO);
+
+/**
+ * Stride alignment for draw buffers.
+ * It may vary between different color formats and hardware.
+ * Refine it to suit your needs.
+ */
+
+#define LV_DRAW_BUF_STRIDE(w, cf) \
+    LV_ROUND_UP(((w) * LV_COLOR_FORMAT_GET_BPP(cf) + 7) / 8, LV_DRAW_BUF_STRIDE_ALIGN)
+
+/** Allocate a slightly larger buffer, so we can adjust the start address to meet alignment */
+#define LV_DRAW_BUF_SIZE(w, h, cf) \
+    (LV_DRAW_BUF_STRIDE(w, cf) * (h) + LV_DRAW_BUF_ALIGN + \
+     LV_COLOR_INDEXED_PALETTE_SIZE(cf) * sizeof(lv_color32_t))
+
+/**
+ * Define a static draw buffer with the given width, height, and color format.
+ * Stride alignment is set to LV_DRAW_BUF_STRIDE_ALIGN.
+ *
+ * For platform that needs special buffer alignment, call LV_DRAW_BUF_INIT_STATIC.
+ */
+#define LV_DRAW_BUF_DEFINE_STATIC(name, _w, _h, _cf) \
+    static LV_ATTRIBUTE_MEM_ALIGN uint8_t buf_##name[LV_DRAW_BUF_SIZE(_w, _h, _cf)]; \
+    static lv_draw_buf_t name = { \
+                                  .header = { \
+                                              .magic = LV_IMAGE_HEADER_MAGIC, \
+                                              .cf = (_cf), \
+                                              .flags = LV_IMAGE_FLAGS_MODIFIABLE, \
+                                              .w = (_w), \
+                                              .h = (_h), \
+                                              .stride = LV_DRAW_BUF_STRIDE(_w, _cf), \
+                                              .reserved_2 = 0, \
+                                            }, \
+                                  .data_size = sizeof(buf_##name), \
+                                  .data = buf_##name, \
+                                  .unaligned_data = buf_##name, \
+                                }
+
+#define LV_DRAW_BUF_INIT_STATIC(name) \
+    do { \
+        lv_image_header_t * header = &name.header; \
+        lv_draw_buf_init(&name, header->w, header->h, (lv_color_format_t)header->cf, header->stride, buf_##name, sizeof(buf_##name)); \
+        lv_draw_buf_set_flag(&name, LV_IMAGE_FLAGS_MODIFIABLE); \
+    } while(0)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef void * (*lv_draw_buf_malloc_cb_t)(size_t size, lv_color_format_t color_format);
+
+typedef void (*lv_draw_buf_free_cb_t)(void * draw_buf);
+
+typedef void (*lv_draw_buf_copy_cb_t)(lv_draw_buf_t * dest, const lv_area_t * dest_area,
+                                      const lv_draw_buf_t * src, const lv_area_t * src_area);
+
+typedef void * (*lv_draw_buf_align_cb_t)(void * buf, lv_color_format_t color_format);
+
+typedef void (*lv_draw_buf_cache_operation_cb_t)(const lv_draw_buf_t * draw_buf, const lv_area_t * area);
+
+typedef uint32_t (*lv_draw_buf_width_to_stride_cb_t)(uint32_t w, lv_color_format_t color_format);
+
+struct _lv_draw_buf_t {
+    lv_image_header_t header;
+    uint32_t data_size;       /**< Total buf size in bytes */
+    uint8_t * data;
+    void * unaligned_data;    /**< Unaligned address of `data`, used internally by lvgl */
+    const lv_draw_buf_handlers_t * handlers; /**< draw buffer alloc/free ops. */
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the draw buffer with the default handlers.
+ *
+ * @param handlers  the draw buffer handlers to set
+ */
+void lv_draw_buf_init_with_default_handlers(lv_draw_buf_handlers_t * handlers);
+
+/**
+ * Initialize the draw buffer with given handlers.
+ *
+ * @param handlers             the draw buffer handlers to set
+ * @param buf_malloc_cb        the callback to allocate memory for the buffer
+ * @param buf_free_cb          the callback to free memory of the buffer
+ * @param buf_copy_cb          the callback to copy a draw buffer to an other
+ * @param align_pointer_cb     the callback to align the buffer
+ * @param invalidate_cache_cb  the callback to invalidate the cache of the buffer
+ * @param flush_cache_cb       the callback to flush buffer
+ * @param width_to_stride_cb   the callback to calculate the stride based on the width and color format
+ */
+void lv_draw_buf_handlers_init(lv_draw_buf_handlers_t * handlers,
+                               lv_draw_buf_malloc_cb_t buf_malloc_cb,
+                               lv_draw_buf_free_cb_t buf_free_cb,
+                               lv_draw_buf_copy_cb_t buf_copy_cb,
+                               lv_draw_buf_align_cb_t align_pointer_cb,
+                               lv_draw_buf_cache_operation_cb_t invalidate_cache_cb,
+                               lv_draw_buf_cache_operation_cb_t flush_cache_cb,
+                               lv_draw_buf_width_to_stride_cb_t width_to_stride_cb);
+
+/**
+ * Get the struct which holds the callbacks for draw buf management.
+ * Custom callback can be set on the returned value
+ * @return                  pointer to the struct of handlers
+ */
+lv_draw_buf_handlers_t * lv_draw_buf_get_handlers(void);
+lv_draw_buf_handlers_t * lv_draw_buf_get_font_handlers(void);
+lv_draw_buf_handlers_t * lv_draw_buf_get_image_handlers(void);
+
+
+/**
+ * Align the address of a buffer. The buffer needs to be large enough for the real data after alignment
+ * @param buf           the data to align
+ * @param color_format  the color format of the buffer
+ * @return              the aligned buffer
+ */
+void * lv_draw_buf_align(void * buf, lv_color_format_t color_format);
+
+/**
+ * Align the address of a buffer with custom draw buffer handlers.
+ * The buffer needs to be large enough for the real data after alignment
+ * @param handlers      the draw buffer handlers
+ * @param buf           the data to align
+ * @param color_format  the color format of the buffer
+ * @return              the aligned buffer
+ */
+void * lv_draw_buf_align_ex(const lv_draw_buf_handlers_t * handlers, void * buf, lv_color_format_t color_format);
+
+/**
+ * Invalidate the cache of the buffer
+ * @param draw_buf     the draw buffer needs to be invalidated
+ * @param area         the area to invalidate in the buffer,
+ *                     use NULL to invalidate the whole draw buffer address range
+ */
+void lv_draw_buf_invalidate_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area);
+
+/**
+ * Flush the cache of the buffer
+ * @param draw_buf     the draw buffer needs to be flushed
+ * @param area         the area to flush in the buffer,
+ *                     use NULL to flush the whole draw buffer address range
+ */
+void lv_draw_buf_flush_cache(const lv_draw_buf_t * draw_buf, const lv_area_t * area);
+
+/**
+ * Calculate the stride in bytes based on a width and color format
+ * @param w                 the width in pixels
+ * @param color_format      the color format
+ * @return                  the stride in bytes
+ */
+uint32_t lv_draw_buf_width_to_stride(uint32_t w, lv_color_format_t color_format);
+
+/**
+ * Calculate the stride in bytes based on a width and color format
+ * @param handlers          the draw buffer handlers
+ * @param w                 the width in pixels
+ * @param color_format      the color format
+ * @return                  the stride in bytes
+ */
+uint32_t lv_draw_buf_width_to_stride_ex(const lv_draw_buf_handlers_t * handlers, uint32_t w,
+                                        lv_color_format_t color_format);
+
+/**
+ * Clear an area on the buffer
+ * @param draw_buf          pointer to draw buffer
+ * @param a                 the area to clear, or NULL to clear the whole buffer
+ */
+void lv_draw_buf_clear(lv_draw_buf_t * draw_buf, const lv_area_t * a);
+
+
+/**
+ * Note: Eventually, lv_draw_buf_malloc/free will be kept as private.
+ *       For now, we use `create` to distinguish with malloc.
+ *
+ * Create an draw buf by allocating struct for `lv_draw_buf_t` and allocating a buffer for it
+ * that meets specified requirements.
+ *
+ * @param w         the buffer width in pixels
+ * @param h         the buffer height in pixels
+ * @param cf        the color format for image
+ * @param stride    the stride in bytes for image. Use 0 for automatic calculation based on
+ *                  w, cf, and global stride alignment configuration.
+ */
+lv_draw_buf_t * lv_draw_buf_create(uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride);
+
+/**
+ * Note: Eventually, lv_draw_buf_malloc/free will be kept as private.
+ *       For now, we use `create` to distinguish with malloc.
+ *
+ * Create an draw buf by allocating struct for `lv_draw_buf_t` and allocating a buffer for it
+ * that meets specified requirements.
+ *
+ * @param handlers  the draw buffer handlers
+ * @param w         the buffer width in pixels
+ * @param h         the buffer height in pixels
+ * @param cf        the color format for image
+ * @param stride    the stride in bytes for image. Use 0 for automatic calculation based on
+ *                  w, cf, and global stride alignment configuration.
+ */
+lv_draw_buf_t * lv_draw_buf_create_ex(const lv_draw_buf_handlers_t * handlers, uint32_t w, uint32_t h,
+                                      lv_color_format_t cf, uint32_t stride);
+
+/**
+ * Duplicate a draw buf with same image size, stride and color format. Copy the image data too.
+ * @param draw_buf  the draw buf to duplicate
+ * @return          the duplicated draw buf on success, NULL if failed
+ */
+lv_draw_buf_t * lv_draw_buf_dup(const lv_draw_buf_t * draw_buf);
+
+/**
+ * Duplicate a draw buf with same image size, stride and color format. Copy the image data too.
+ * @param handlers  the draw buffer handlers
+ * @param draw_buf  the draw buf to duplicate
+ * @return          the duplicated draw buf on success, NULL if failed
+ */
+lv_draw_buf_t * lv_draw_buf_dup_ex(const lv_draw_buf_handlers_t * handlers, const lv_draw_buf_t * draw_buf);
+
+/**
+ * Initialize a draw buf with the given buffer and parameters. Clear draw buffer flag to zero.
+ * @param draw_buf  the draw buf to initialize
+ * @param w         the buffer width in pixels
+ * @param h         the buffer height in pixels
+ * @param cf        the color format
+ * @param stride    the stride in bytes. Use 0 for automatic calculation
+ * @param data      the buffer used for drawing. Unaligned `data` will be aligned internally
+ * @param data_size the size of the buffer in bytes
+ * @return          return LV_RESULT_OK on success, LV_RESULT_INVALID otherwise
+ */
+lv_result_t lv_draw_buf_init(lv_draw_buf_t * draw_buf, uint32_t w, uint32_t h, lv_color_format_t cf, uint32_t stride,
+                             void * data, uint32_t data_size);
+
+/**
+ * Keep using the existing memory, reshape the draw buffer to the given width and height.
+ * Return NULL if data_size is smaller than the required size.
+ * @param draw_buf  pointer to a draw buffer
+ * @param cf        the new color format, use 0 or LV_COLOR_FORMAT_UNKNOWN to keep using the original color format.
+ * @param w         the new width in pixels
+ * @param h         the new height in pixels
+ * @param stride    the stride in bytes for image. Use 0 for automatic calculation.
+ */
+lv_draw_buf_t * lv_draw_buf_reshape(lv_draw_buf_t * draw_buf, lv_color_format_t cf, uint32_t w, uint32_t h,
+                                    uint32_t stride);
+
+/**
+ * Destroy a draw buf by freeing the actual buffer if it's marked as LV_IMAGE_FLAGS_ALLOCATED in header.
+ * Then free the lv_draw_buf_t struct.
+ *
+ * @param draw_buf  the draw buffer to destroy
+ */
+void lv_draw_buf_destroy(lv_draw_buf_t * draw_buf);
+
+/**
+ * Copy an area from a buffer to another
+ * @param dest      pointer to the destination draw buffer
+ * @param dest_area the area to copy from the destination buffer, if NULL, use the whole buffer
+ * @param src       pointer to the source draw buffer
+ * @param src_area  the area to copy from the destination buffer, if NULL, use the whole buffer
+ * @note `dest_area` and `src_area` should have the same width and height
+ * @note  The default copy function required `dest` and `src` to have the same color format.
+ * Overwriting dest->handlers->buf_copy_cb can resolve this limitation.
+ */
+void lv_draw_buf_copy(lv_draw_buf_t * dest, const lv_area_t * dest_area,
+                      const lv_draw_buf_t * src, const lv_area_t * src_area);
+
+/**
+ * Return pointer to the buffer at the given coordinates
+ */
+void * lv_draw_buf_goto_xy(const lv_draw_buf_t * buf, uint32_t x, uint32_t y);
+
+/**
+ * Adjust the stride of a draw buf in place.
+ * @param src       pointer to a draw buffer
+ * @param stride    the new stride in bytes for image. Use LV_STRIDE_AUTO for automatic calculation.
+ * @return          LV_RESULT_OK: success or LV_RESULT_INVALID: failed
+ */
+lv_result_t lv_draw_buf_adjust_stride(lv_draw_buf_t * src, uint32_t stride);
+
+/**
+ * Premultiply draw buffer color with alpha channel.
+ * If it's already premultiplied, return directly.
+ * Only color formats with alpha channel will be processed.
+ *
+ * @return LV_RESULT_OK: premultiply success
+ */
+lv_result_t lv_draw_buf_premultiply(lv_draw_buf_t * draw_buf);
+
+bool lv_draw_buf_has_flag(const lv_draw_buf_t * draw_buf, lv_image_flags_t flag);
+
+void lv_draw_buf_set_flag(lv_draw_buf_t * draw_buf, lv_image_flags_t flag);
+
+void lv_draw_buf_clear_flag(lv_draw_buf_t * draw_buf, lv_image_flags_t flag);
+
+/**
+ * As of now, draw buf share same definition as `lv_image_dsc_t`.
+ * And is interchangeable with `lv_image_dsc_t`.
+ */
+
+lv_result_t lv_draw_buf_from_image(lv_draw_buf_t * buf, const lv_image_dsc_t * img);
+
+void lv_draw_buf_to_image(const lv_draw_buf_t * buf, lv_image_dsc_t * img);
+
+/**
+ * Set the palette color of an indexed image. Valid only for `LV_COLOR_FORMAT_I1/2/4/8`
+ * @param draw_buf pointer to an image descriptor
+ * @param index the palette color to set:
+ *   - for `LV_COLOR_FORMAT_I1`: 0..1
+ *   - for `LV_COLOR_FORMAT_I2`: 0..3
+ *   - for `LV_COLOR_FORMAT_I4`: 0..15
+ *   - for `LV_COLOR_FORMAT_I8`: 0..255
+ * @param color the color to set in lv_color32_t format
+ */
+void lv_draw_buf_set_palette(lv_draw_buf_t * draw_buf, uint8_t index, lv_color32_t color);
+
+/**
+ * @deprecated Use lv_draw_buf_set_palette instead.
+ */
+void lv_image_buf_set_palette(lv_image_dsc_t * dsc, uint8_t id, lv_color32_t c);
+
+/**
+ * @deprecated Use lv_draw_buffer_create/destroy instead.
+ * Free the data pointer and dsc struct of an image.
+ */
+void lv_image_buf_free(lv_image_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_BUF_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_buf_private.h

@@ -0,0 +1,54 @@
+/**
+ * @file lv_draw_buf_private.h
+ *
+ */
+
+#ifndef LV_DRAW_BUF_PRIVATE_H
+#define LV_DRAW_BUF_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_buf.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_draw_buf_handlers_t {
+    lv_draw_buf_malloc_cb_t buf_malloc_cb;
+    lv_draw_buf_free_cb_t buf_free_cb;
+    lv_draw_buf_copy_cb_t buf_copy_cb;
+    lv_draw_buf_align_cb_t align_pointer_cb;
+    lv_draw_buf_cache_operation_cb_t invalidate_cache_cb;
+    lv_draw_buf_cache_operation_cb_t flush_cache_cb;
+    lv_draw_buf_width_to_stride_cb_t width_to_stride_cb;
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Called internally to initialize the draw_buf_handlers in lv_global
+ */
+void lv_draw_buf_init_handlers(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_BUF_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_image.c

@@ -0,0 +1,378 @@
+/**
+ * @file lv_draw_image.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_image_private.h"
+#include "../misc/lv_area_private.h"
+#include "lv_image_decoder_private.h"
+#include "lv_draw_private.h"
+#include "../display/lv_display.h"
+#include "../misc/lv_log.h"
+#include "../misc/lv_math.h"
+#include "../core/lv_refr.h"
+#include "../core/lv_obj_private.h"
+#include "../stdlib/lv_mem.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void img_decode_and_draw(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                lv_image_decoder_dsc_t * decoder_dsc, lv_area_t * relative_decoded_area,
+                                const lv_area_t * img_area, const lv_area_t * clipped_img_area,
+                                lv_draw_image_core_cb draw_core_cb);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_image_dsc_init(lv_draw_image_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_image_dsc_t));
+    dsc->recolor = lv_color_black();
+    dsc->opa = LV_OPA_COVER;
+    dsc->scale_x = LV_SCALE_NONE;
+    dsc->scale_y = LV_SCALE_NONE;
+    dsc->antialias = LV_COLOR_DEPTH > 8 ? 1 : 0;
+    dsc->image_area.x2 = LV_COORD_MIN;   /*Indicate invalid area by default by setting a negative size*/
+    dsc->base.dsc_size = sizeof(lv_draw_image_dsc_t);
+}
+
+lv_draw_image_dsc_t * lv_draw_task_get_image_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_IMAGE ? (lv_draw_image_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_layer(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv_area_t * coords)
+{
+    if(dsc->scale_x <= 0 || dsc->scale_y <= 0) {
+        /* NOT draw if scale is negative or zero */
+        return;
+    }
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LAYER);
+    lv_draw_image_dsc_t * new_image_dsc = t->draw_dsc;
+    lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
+    t->state = LV_DRAW_TASK_STATE_BLOCKED;
+
+    lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(coords), lv_area_get_height(coords),
+                                      dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
+    lv_area_move(&t->_real_area, coords->x1, coords->y1);
+
+    /*If the image_area is not set assume that it's the same as the rendering area */
+    if(new_image_dsc->image_area.x2 == LV_COORD_MIN) {
+        new_image_dsc->image_area = *coords;
+    }
+
+    lv_layer_t * layer_to_draw = (lv_layer_t *)dsc->src;
+    layer_to_draw->all_tasks_added = true;
+
+    lv_draw_finalize_task_creation(layer, t);
+
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv_area_t * image_coords)
+{
+    if(dsc->src == NULL) {
+        LV_LOG_WARN("Image draw: src is NULL");
+        return;
+    }
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    if(dsc->scale_x <= 0 || dsc->scale_y <= 0) {
+        /* NOT draw if scale is negative or zero */
+        return;
+    }
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_draw_image_dsc_t new_image_dsc;
+    lv_memcpy(&new_image_dsc, dsc, sizeof(*dsc));
+    lv_result_t res = lv_image_decoder_get_info(new_image_dsc.src, &new_image_dsc.header);
+    if(res != LV_RESULT_OK) {
+        LV_LOG_WARN("Couldn't get info about the image");
+        LV_PROFILER_DRAW_END;
+        return;
+    }
+
+    /*If the image_area is not set assume that it's the same as the rendering area */
+    if(new_image_dsc.image_area.x2 == LV_COORD_MIN) {
+        new_image_dsc.image_area = *image_coords;
+    }
+
+    /*Typical case, draw the image as bitmap*/
+    if(!(new_image_dsc.header.flags & LV_IMAGE_FLAGS_CUSTOM_DRAW)) {
+        lv_draw_task_t * t = lv_draw_add_task(layer, image_coords, LV_DRAW_TASK_TYPE_IMAGE);
+        lv_memcpy(t->draw_dsc, &new_image_dsc, sizeof(lv_draw_image_dsc_t));
+
+        lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(image_coords), lv_area_get_height(image_coords),
+                                          dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
+        lv_area_move(&t->_real_area, image_coords->x1, image_coords->y1);
+
+        lv_draw_finalize_task_creation(layer, t);
+    }
+    /*Use a custom draw callback*/
+    else {
+
+        lv_image_decoder_dsc_t decoder_dsc;
+        res = lv_image_decoder_open(&decoder_dsc, new_image_dsc.src, NULL);
+        if(res != LV_RESULT_OK) {
+            LV_LOG_ERROR("Failed to open image");
+            LV_PROFILER_DRAW_END;
+            return;
+        }
+
+        if(decoder_dsc.decoder && decoder_dsc.decoder->custom_draw_cb) {
+            lv_area_t draw_area = layer->buf_area;
+            lv_area_t coords_area = *image_coords;
+
+            lv_area_t obj_area = dsc->base.obj->coords;
+            if(layer->parent) { /* child layer */
+                if(lv_area_intersect(&coords_area, &coords_area, &obj_area)) {
+                    int32_t xpos = image_coords->x1 - draw_area.x1;
+                    int32_t ypos = image_coords->y1 - draw_area.y1;
+
+                    lv_area_move(&coords_area, -(image_coords->x1 - xpos), -(image_coords->y1 - ypos));
+                    layer->_clip_area = coords_area;
+                    decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &coords_area);
+                }
+            }
+            else {
+                lv_area_t clip_area = draw_area;
+                if(lv_area_intersect(&clip_area, &clip_area, &coords_area)) {
+
+                    lv_image_buf_get_transformed_area(&coords_area, lv_area_get_width(image_coords), lv_area_get_height(image_coords),
+                                                      dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
+                    lv_area_move(&coords_area, image_coords->x1, image_coords->y1);
+
+                    lv_image_buf_get_transformed_area(&clip_area, lv_area_get_width(image_coords), lv_area_get_height(image_coords),
+                                                      dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
+                    lv_area_move(&clip_area, image_coords->x1, image_coords->y1);
+
+                    if(lv_area_intersect(&clip_area, &clip_area, &obj_area)) {
+                        decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &clip_area);
+                    }
+                }
+            }
+
+        }
+
+        lv_image_decoder_close(&decoder_dsc);
+    }
+
+    LV_PROFILER_DRAW_END;
+}
+
+lv_image_src_t lv_image_src_get_type(const void * src)
+{
+    if(src == NULL) return LV_IMAGE_SRC_UNKNOWN;
+    const uint8_t * u8_p = src;
+
+    /*The first byte shows the type of the image source*/
+    if(u8_p[0] >= 0x20 && u8_p[0] <= 0x7F) {
+        return LV_IMAGE_SRC_FILE; /*If it's an ASCII character then it's file name*/
+    }
+    else if(u8_p[0] >= 0x80) {
+        return LV_IMAGE_SRC_SYMBOL; /*Symbols begins after 0x7F*/
+    }
+    else {
+        return LV_IMAGE_SRC_VARIABLE; /*`lv_image_dsc_t` is draw to the first byte < 0x20*/
+    }
+}
+
+void lv_draw_image_normal_helper(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                 const lv_area_t * coords, lv_draw_image_core_cb draw_core_cb)
+{
+    if(draw_core_cb == NULL) {
+        LV_LOG_WARN("draw_core_cb is NULL");
+        return;
+    }
+
+    lv_area_t draw_area;
+    lv_area_copy(&draw_area, coords);
+    if(draw_dsc->rotation || draw_dsc->scale_x != LV_SCALE_NONE || draw_dsc->scale_y != LV_SCALE_NONE) {
+        int32_t w = lv_area_get_width(coords);
+        int32_t h = lv_area_get_height(coords);
+
+        lv_image_buf_get_transformed_area(&draw_area, w, h, draw_dsc->rotation, draw_dsc->scale_x, draw_dsc->scale_y,
+                                          &draw_dsc->pivot);
+
+        draw_area.x1 += coords->x1;
+        draw_area.y1 += coords->y1;
+        draw_area.x2 += coords->x1;
+        draw_area.y2 += coords->y1;
+    }
+
+    lv_area_t clipped_img_area;
+    if(!lv_area_intersect(&clipped_img_area, &draw_area, &t->clip_area)) {
+        return;
+    }
+
+    lv_image_decoder_dsc_t decoder_dsc;
+    lv_result_t res = lv_image_decoder_open(&decoder_dsc, draw_dsc->src, NULL);
+    if(res != LV_RESULT_OK) {
+        LV_LOG_ERROR("Failed to open image");
+        return;
+    }
+
+    img_decode_and_draw(t, draw_dsc, &decoder_dsc, NULL, coords, &clipped_img_area, draw_core_cb);
+
+    lv_image_decoder_close(&decoder_dsc);
+}
+
+void lv_draw_image_tiled_helper(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                const lv_area_t * coords, lv_draw_image_core_cb draw_core_cb)
+{
+    if(draw_core_cb == NULL) {
+        LV_LOG_WARN("draw_core_cb is NULL");
+        return;
+    }
+
+    lv_image_decoder_dsc_t decoder_dsc;
+    lv_result_t res = lv_image_decoder_open(&decoder_dsc, draw_dsc->src, NULL);
+    if(res != LV_RESULT_OK) {
+        LV_LOG_ERROR("Failed to open image");
+        return;
+    }
+
+    int32_t img_w = draw_dsc->header.w;
+    int32_t img_h = draw_dsc->header.h;
+
+    lv_area_t tile_area;
+    if(lv_area_get_width(&draw_dsc->image_area) >= 0) {
+        tile_area = draw_dsc->image_area;
+    }
+    else {
+        tile_area = *coords;
+    }
+    lv_area_set_width(&tile_area, img_w);
+    lv_area_set_height(&tile_area, img_h);
+
+    int32_t tile_x_start = tile_area.x1;
+
+    lv_area_t relative_decoded_area = {
+        .x1 = LV_COORD_MIN,
+        .y1 = LV_COORD_MIN,
+        .x2 = LV_COORD_MIN,
+        .y2 = LV_COORD_MIN,
+    };
+
+    while(tile_area.y1 <= coords->y2) {
+        while(tile_area.x1 <= coords->x2) {
+
+            lv_area_t clipped_img_area;
+            if(lv_area_intersect(&clipped_img_area, &tile_area, coords)) {
+                img_decode_and_draw(t, draw_dsc, &decoder_dsc, &relative_decoded_area, &tile_area, &clipped_img_area,
+                                    draw_core_cb);
+            }
+
+            tile_area.x1 += img_w;
+            tile_area.x2 += img_w;
+        }
+
+        tile_area.y1 += img_h;
+        tile_area.y2 += img_h;
+        tile_area.x1 = tile_x_start;
+        tile_area.x2 = tile_x_start + img_w - 1;
+    }
+
+    lv_image_decoder_close(&decoder_dsc);
+}
+
+void lv_image_buf_get_transformed_area(lv_area_t * res, int32_t w, int32_t h, int32_t angle,
+                                       uint16_t scale_x, uint16_t scale_y, const lv_point_t * pivot)
+{
+    if(angle == 0 && scale_x == LV_SCALE_NONE && scale_y == LV_SCALE_NONE) {
+        res->x1 = 0;
+        res->y1 = 0;
+        res->x2 = w - 1;
+        res->y2 = h - 1;
+        return;
+    }
+
+    lv_point_t p[4] = {
+        {0, 0},
+        {w, 0},
+        {0, h},
+        {w, h},
+    };
+    lv_point_transform(&p[0], angle, scale_x, scale_y, pivot, true);
+    lv_point_transform(&p[1], angle, scale_x, scale_y, pivot, true);
+    lv_point_transform(&p[2], angle, scale_x, scale_y, pivot, true);
+    lv_point_transform(&p[3], angle, scale_x, scale_y, pivot, true);
+    res->x1 = LV_MIN4(p[0].x, p[1].x, p[2].x, p[3].x);
+    res->x2 = LV_MAX4(p[0].x, p[1].x, p[2].x, p[3].x) - 1;
+    res->y1 = LV_MIN4(p[0].y, p[1].y, p[2].y, p[3].y);
+    res->y2 = LV_MAX4(p[0].y, p[1].y, p[2].y, p[3].y) - 1;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void img_decode_and_draw(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                lv_image_decoder_dsc_t * decoder_dsc, lv_area_t * relative_decoded_area,
+                                const lv_area_t * img_area, const lv_area_t * clipped_img_area,
+                                lv_draw_image_core_cb draw_core_cb)
+{
+    lv_draw_image_sup_t sup;
+    sup.alpha_color = draw_dsc->recolor;
+    sup.palette = decoder_dsc->palette;
+    sup.palette_size = decoder_dsc->palette_size;
+
+    /*The whole image is available, just draw it*/
+    if(decoder_dsc->decoded && (relative_decoded_area == NULL || relative_decoded_area->x1 == LV_COORD_MIN)) {
+        draw_core_cb(t, draw_dsc, decoder_dsc, &sup, img_area, clipped_img_area);
+    }
+    /*Draw in smaller pieces*/
+    else {
+        lv_area_t relative_full_area_to_decode = *clipped_img_area;
+        lv_area_move(&relative_full_area_to_decode, -img_area->x1, -img_area->y1);
+        lv_area_t tmp;
+        if(relative_decoded_area == NULL) relative_decoded_area = &tmp;
+        relative_decoded_area->x1 = LV_COORD_MIN;
+        relative_decoded_area->y1 = LV_COORD_MIN;
+        relative_decoded_area->x2 = LV_COORD_MIN;
+        relative_decoded_area->y2 = LV_COORD_MIN;
+        lv_result_t res = LV_RESULT_OK;
+
+        while(res == LV_RESULT_OK) {
+            res = lv_image_decoder_get_area(decoder_dsc, &relative_full_area_to_decode, relative_decoded_area);
+
+            lv_area_t absolute_decoded_area = *relative_decoded_area;
+            lv_area_move(&absolute_decoded_area, img_area->x1, img_area->y1);
+            if(res == LV_RESULT_OK) {
+                /*Limit draw area to the current decoded area and draw the image*/
+                lv_area_t clipped_img_area_sub;
+                if(lv_area_intersect(&clipped_img_area_sub, clipped_img_area, &absolute_decoded_area)) {
+                    draw_core_cb(t, draw_dsc, decoder_dsc, &sup,
+                                 &absolute_decoded_area, &clipped_img_area_sub);
+                }
+            }
+        }
+    }
+}

components/easylvgl/lvgl9/src/draw/lv_draw_image.h

@@ -0,0 +1,167 @@
+/**
+ * @file lv_draw_image.h
+ *
+ */
+
+#ifndef LV_DRAW_IMAGE_H
+#define LV_DRAW_IMAGE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+#include "lv_image_decoder.h"
+#include "lv_draw_buf.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+struct _lv_draw_image_dsc_t {
+    lv_draw_dsc_base_t base;
+
+    /**The image source: pointer to `lv_image_dsc_t` or a path to a file*/
+    const void * src;
+
+    /**The header of the image. Initialized internally in `lv_draw_image` */
+    lv_image_header_t header;
+
+    /**Clip the corner of the image with this radius. Use `LV_RADIUS_CIRCLE` for max. radius */
+    int32_t clip_radius;
+
+    /**The rotation of the image in 0.1 degree unit. E.g. 234 means 23.4° */
+    int32_t rotation;
+
+    /**Horizontal scale (zoom) of the image.
+     * 256 (LV_SCALE_NONE): means no zoom, 512 double size, 128 half size.*/
+    int32_t scale_x;
+
+    /**Same as `scale_y` but vertically*/
+    int32_t scale_y;
+
+    /**Parallelogram like transformation of the image horizontally in 0.1 degree unit. E.g. 456 means 45.6°.*/
+    int32_t skew_x;
+
+    /**Same as `skew_x` but vertically*/
+    int32_t skew_y;
+
+    /**The pivot point of transformation (scale and rotation).
+     * 0;0 is the top left corner of the image. Can be outside of the image too.*/
+    lv_point_t pivot;
+
+    /**Mix this color to the images. In case of `LV_COLOR_FORMAT_A8` it will be the color of the visible pixels*/
+    lv_color_t recolor;
+
+    /**The intensity of recoloring. 0 means, no recolor, 255 means full cover (transparent pixels remain transparent)*/
+    lv_opa_t recolor_opa;
+
+    /**Opacity in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**Describes how to blend the pixels of the image to the background.
+     * See `lv_blend_mode_t` for more details.
+     */
+    lv_blend_mode_t blend_mode : 4;
+
+    /**1: perform the transformation with anti-aliasing */
+    uint16_t antialias          : 1;
+
+    /**If the image is smaller than the `image_area` field of `lv_draw_image_dsc_t`
+     * tile the image (repeat is both horizontally and vertically) to fill the
+     * `image_area` area*/
+    uint16_t tile               : 1;
+
+    const lv_image_colorkey_t * colorkey;
+
+    /**Used internally to store some information about the palette or the color of A8 images*/
+    lv_draw_image_sup_t * sup;
+
+    /** Used to indicate the entire original, non-clipped area where the image is to be drawn.
+     * This is important for:
+     *  1. Layer rendering, where it might happen that only a smaller area of the layer is rendered and e.g.
+     *     `clip_radius` needs to know what the original image was.
+     *  2. Tiled images, where the target draw area is larger than the image to be tiled.
+     */
+    lv_area_t image_area;
+
+    /**Pointer to an A8 or L8 image descriptor to mask the image with.
+     * The mask is always center aligned. */
+    const lv_image_dsc_t * bitmap_mask_src;
+};
+
+/**
+ * PErform the actual rendering of a decoded image
+ * @param t                 pointer to a draw task
+ * @param draw_dsc          the draw descriptor of the image
+ * @param decoder_dsc       pointer to the decoded image's descriptor
+ * @param sup               supplementary data
+ * @param img_coords        the absolute coordinates of the image
+ * @param clipped_img_area  the absolute clip coordinates
+ */
+typedef void (*lv_draw_image_core_cb)(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                      const lv_image_decoder_dsc_t * decoder_dsc, lv_draw_image_sup_t * sup,
+                                      const lv_area_t * img_coords, const lv_area_t * clipped_img_area);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize an image draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_image_dsc_init(lv_draw_image_dsc_t * dsc);
+
+/**
+ * Try to get an image draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_IMAGE
+ */
+lv_draw_image_dsc_t * lv_draw_task_get_image_dsc(lv_draw_task_t * task);
+
+/**
+ * Create an image draw task
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor
+ * @param coords        the coordinates of the image
+ * @note                `coords` can be small than the real image area
+ *                      (if only a part of the image is rendered)
+ *                      or can be larger (in case of tiled images).   .
+ */
+void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv_area_t * coords);
+
+/**
+ * Create a draw task to blend a layer to another layer
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor. `src` must be set to the layer to blend
+ * @param coords        the coordinates of the layer.
+ * @note                `coords` can be small than the total widget area from which the layer is created
+ *                      (if only a part of the widget was rendered to a layer)
+ */
+void lv_draw_layer(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv_area_t * coords);
+
+/**
+ * Get the type of an image source
+ * @param src pointer to an image source:
+ *  - pointer to an 'lv_image_t' variable (image stored internally and compiled into the code)
+ *  - a path to a file (e.g. "S:/folder/image.bin")
+ *  - or a symbol (e.g. LV_SYMBOL_CLOSE)
+ * @return type of the image source LV_IMAGE_SRC_VARIABLE/FILE/SYMBOL/UNKNOWN
+ */
+lv_image_src_t lv_image_src_get_type(const void * src);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_IMAGE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_image_private.h

@@ -0,0 +1,85 @@
+/**
+ * @file lv_draw_image_private.h
+ *
+ */
+
+#ifndef LV_DRAW_IMAGE_PRIVATE_H
+#define LV_DRAW_IMAGE_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_image.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_draw_image_sup_t {
+    lv_color_t alpha_color;
+    const lv_color32_t * palette;
+    uint32_t palette_size   : 9;
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Can be used by draw units to handle the decoding and
+ * prepare everything for the actual image rendering
+ * @param t             pointer to a draw task
+ * @param draw_dsc      the draw descriptor of the image
+ * @param coords        the absolute coordinates of the image
+ * @param draw_core_cb  a callback to perform the actual rendering
+ */
+void lv_draw_image_normal_helper(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                 const lv_area_t * coords, lv_draw_image_core_cb draw_core_cb);
+
+/**
+ * Can be used by draw units for TILED images to handle the decoding and
+ * prepare everything for the actual image rendering
+ * @param t             pointer to a draw task
+ * @param draw_dsc      the draw descriptor of the image
+ * @param coords        the absolute coordinates of the image
+ * @param draw_core_cb  a callback to perform the actual rendering
+ */
+void lv_draw_image_tiled_helper(lv_draw_task_t * t, const lv_draw_image_dsc_t * draw_dsc,
+                                const lv_area_t * coords, lv_draw_image_core_cb draw_core_cb);
+
+/**
+ * Get the area of a rectangle if its rotated and scaled
+ * @param res store the coordinates here
+ * @param w width of the rectangle to transform
+ * @param h height of the rectangle to transform
+ * @param angle angle of rotation
+ * @param scale_x zoom in x direction, (256 no zoom)
+ * @param scale_y zoom in y direction, (256 no zoom)
+ * @param pivot x,y pivot coordinates of rotation
+ */
+void lv_image_buf_get_transformed_area(lv_area_t * res, int32_t w, int32_t h, int32_t angle,
+                                       uint16_t scale_x, uint16_t scale_y, const lv_point_t * pivot);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_IMAGE_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_label.c

@@ -0,0 +1,663 @@
+/**
+ * @file lv_draw_label.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_label_private.h"
+#include "lv_draw_private.h"
+#include "../misc/lv_area_private.h"
+#include "lv_draw_vector_private.h"
+#include "lv_draw_rect_private.h"
+#include "../core/lv_obj.h"
+#include "../misc/lv_math.h"
+#include "../core/lv_obj_event.h"
+#include "../misc/lv_bidi_private.h"
+#include "../misc/lv_text_private.h"
+#include "../misc/lv_assert.h"
+#include "../stdlib/lv_mem.h"
+#include "../stdlib/lv_string.h"
+#include "../core/lv_global.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LABEL_RECOLOR_PAR_LENGTH 6
+#define LV_LABEL_HINT_UPDATE_TH 1024 /*Update the "hint" if the label's y coordinates have changed more then this*/
+
+#define font_draw_buf_handlers &(LV_GLOBAL_DEFAULT()->font_draw_buf_handlers)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum {
+    RECOLOR_CMD_STATE_WAIT_FOR_PARAMETER,
+    RECOLOR_CMD_STATE_PARAMETER,
+    RECOLOR_CMD_STATE_TEXT_INPUT,
+};
+typedef unsigned char cmd_state_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static uint8_t hex_char_to_num(char hex);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_letter_dsc_init(lv_draw_letter_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_letter_dsc_t));
+    dsc->opa = LV_OPA_COVER;
+    dsc->color = lv_color_black();
+    dsc->font = LV_FONT_DEFAULT;
+    dsc->rotation = 0;
+    dsc->scale_x = LV_SCALE_NONE;
+    dsc->scale_y = LV_SCALE_NONE;
+    dsc->base.dsc_size = sizeof(lv_draw_letter_dsc_t);
+}
+
+void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_label_dsc_t));
+    dsc->opa = LV_OPA_COVER;
+    dsc->color = lv_color_black();
+    dsc->text_length = LV_TEXT_LEN_MAX;
+    dsc->font = LV_FONT_DEFAULT;
+    dsc->sel_start = LV_DRAW_LABEL_NO_TXT_SEL;
+    dsc->sel_end = LV_DRAW_LABEL_NO_TXT_SEL;
+    dsc->sel_color = lv_color_black();
+    dsc->sel_bg_color = lv_palette_main(LV_PALETTE_BLUE);
+    dsc->bidi_dir = LV_BASE_DIR_LTR;
+    dsc->base.dsc_size = sizeof(lv_draw_label_dsc_t);
+}
+
+lv_draw_label_dsc_t * lv_draw_task_get_label_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_LABEL ? (lv_draw_label_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_glyph_dsc_init(lv_draw_glyph_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_glyph_dsc_t));
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_label(lv_layer_t * layer, const lv_draw_label_dsc_t * dsc,
+                                         const lv_area_t * coords)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->text == NULL || dsc->text[0] == '\0') return;
+    if(dsc->font == NULL) {
+        LV_LOG_WARN("dsc->font == NULL");
+        return;
+    }
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LABEL);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    /*The text is stored in a local variable so malloc memory for it*/
+    if(dsc->text_local) {
+        lv_draw_label_dsc_t * new_dsc = t->draw_dsc;
+        new_dsc->text = lv_strndup(dsc->text, dsc->text_length);
+        LV_ASSERT_MALLOC(new_dsc->text);
+    }
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_character(lv_layer_t * layer, lv_draw_label_dsc_t * dsc,
+                                             const lv_point_t * point, uint32_t unicode_letter)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->font == NULL) {
+        LV_LOG_WARN("dsc->font == NULL");
+        return;
+    }
+
+    if(lv_text_is_marker(unicode_letter)) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_font_glyph_dsc_t g;
+
+    lv_font_get_glyph_dsc(dsc->font, &g, unicode_letter, 0);
+
+    lv_area_t a;
+    a.x1 = point->x;
+    a.y1 = point->y;
+    a.x2 = a.x1 + g.adv_w;
+    a.y2 = a.y1 + lv_font_get_line_height(g.resolved_font ? g.resolved_font : dsc->font);
+
+    /*lv_draw_label needs UTF8 text so convert the Unicode character to an UTF8 string */
+    uint32_t letter_buf[2];
+    letter_buf[0] = lv_text_unicode_to_encoded(unicode_letter);
+    letter_buf[1] = '\0';
+
+    const char * letter_buf_char = (const char *)letter_buf;
+
+#if LV_BIG_ENDIAN_SYSTEM
+    while(*letter_buf_char == 0) ++letter_buf_char;
+#endif
+
+    dsc->text = letter_buf_char;
+    dsc->text_local = 1;
+
+    lv_draw_label(layer, dsc, &a);
+    LV_PROFILER_DRAW_END;
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_letter(lv_layer_t * layer, lv_draw_letter_dsc_t * dsc, const lv_point_t * point)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->font == NULL) {
+        LV_LOG_WARN("dsc->font == NULL");
+        return;
+    }
+
+    const lv_font_t * font = dsc->font;
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_font_glyph_dsc_t g;
+
+    lv_font_get_glyph_dsc(font, &g, dsc->unicode, 0);
+
+    font = g.resolved_font ? g.resolved_font : dsc->font;
+
+    lv_area_t a;
+    a.x1 = point->x;
+    a.y1 = point->y;
+    a.x2 = a.x1 + g.adv_w;
+    a.y2 = a.y1 + lv_font_get_line_height(font);
+
+    dsc->pivot.x = g.adv_w / 2 ;
+    dsc->pivot.y = font->line_height - font->base_line;
+
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LETTER);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_label_iterate_characters(lv_draw_task_t * t, const lv_draw_label_dsc_t * dsc,
+                                      const lv_area_t * coords,
+                                      lv_draw_glyph_cb_t cb)
+{
+    lv_draw_dsc_base_t * base_dsc = t->draw_dsc;
+    const lv_font_t * font = dsc->font;
+    int32_t w;
+
+    lv_area_t clipped_area;
+    bool clip_ok = lv_area_intersect(&clipped_area, coords, &t->clip_area);
+    if(!clip_ok) return;
+
+    lv_text_align_t align = dsc->align;
+    lv_base_dir_t base_dir = dsc->bidi_dir;
+
+    lv_bidi_calculate_align(&align, &base_dir, dsc->text);
+
+    if((dsc->flag & LV_TEXT_FLAG_EXPAND) == 0) {
+        /*Normally use the label's width as width*/
+        w = lv_area_get_width(coords);
+    }
+    else {
+        /*If EXPAND is enabled then not limit the text's width to the object's width*/
+        if(base_dsc->obj && !lv_obj_has_flag(base_dsc->obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS)) {
+            w = dsc->text_size.x;
+        }
+        else {
+            lv_text_attributes_t attributes = {0};
+
+            attributes.letter_space = dsc->letter_space;
+            attributes.line_space = dsc->line_space;
+            attributes.max_width = LV_COORD_MAX;
+            attributes.text_flags = dsc->flag;
+
+            lv_point_t p;
+            lv_text_get_size_attributes(&p, dsc->text, dsc->font, &attributes);
+            w = p.x;
+        }
+    }
+
+    int32_t line_height_font = lv_font_get_line_height(font);
+    int32_t line_height = line_height_font + dsc->line_space;
+
+    /*Init variables for the first line*/
+    int32_t line_width = 0;
+    lv_point_t pos;
+    lv_point_set(&pos, coords->x1, coords->y1);
+
+    int32_t x_ofs = 0;
+    int32_t y_ofs = 0;
+    x_ofs = dsc->ofs_x;
+    y_ofs = dsc->ofs_y;
+    pos.y += y_ofs;
+
+    uint32_t line_start     = 0;
+    int32_t last_line_start = -1;
+
+    /*Check the hint to use the cached info*/
+    if(dsc->hint && y_ofs == 0 && coords->y1 < 0) {
+        /*If the label changed too much recalculate the hint.*/
+        if(LV_ABS(dsc->hint->coord_y - coords->y1) > LV_LABEL_HINT_UPDATE_TH - 2 * line_height) {
+            dsc->hint->line_start = -1;
+        }
+        last_line_start = dsc->hint->line_start;
+    }
+
+    /*Use the hint if it's valid*/
+    if(dsc->hint && last_line_start >= 0) {
+        line_start = last_line_start;
+        pos.y += dsc->hint->y;
+    }
+
+    uint32_t remaining_len = dsc->text_length;
+    lv_text_attributes_t attributes = {0};
+    attributes.letter_space = dsc->letter_space;
+    attributes.text_flags = dsc->flag;
+    attributes.max_width = w;
+
+    uint32_t line_end = line_start + lv_text_get_next_line(&dsc->text[line_start], remaining_len, font, NULL, &attributes);
+
+    /*Go the first visible line*/
+    while(pos.y + line_height_font < t->clip_area.y1) {
+        /*Go to next line*/
+        remaining_len -= line_end - line_start;
+        line_start = line_end;
+        line_end += lv_text_get_next_line(&dsc->text[line_start], remaining_len, font, NULL, &attributes);
+        pos.y += line_height;
+
+        /*Save at the threshold coordinate*/
+        if(dsc->hint && pos.y >= -LV_LABEL_HINT_UPDATE_TH && dsc->hint->line_start < 0) {
+            dsc->hint->line_start = line_start;
+            dsc->hint->y          = pos.y - coords->y1;
+            dsc->hint->coord_y    = coords->y1;
+        }
+
+        if(dsc->text[line_start] == '\0') return;
+    }
+
+    /*Align to middle*/
+    if(align == LV_TEXT_ALIGN_CENTER) {
+        line_width = lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, &attributes);
+        pos.x += (lv_area_get_width(coords) - line_width) / 2;
+
+    }
+    /*Align to the right*/
+    else if(align == LV_TEXT_ALIGN_RIGHT) {
+        line_width = lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, &attributes);
+        pos.x += lv_area_get_width(coords) - line_width;
+    }
+
+    uint32_t sel_start = dsc->sel_start;
+    uint32_t sel_end = dsc->sel_end;
+    if(sel_start > sel_end) {
+        uint32_t tmp = sel_start;
+        sel_start = sel_end;
+        sel_end = tmp;
+    }
+
+    lv_area_t bg_coords;
+    lv_draw_glyph_dsc_t draw_letter_dsc;
+    lv_font_glyph_dsc_t glyph_dsc;
+    lv_draw_glyph_dsc_init(&draw_letter_dsc);
+    draw_letter_dsc.opa = dsc->opa;
+    draw_letter_dsc.bg_coords = &bg_coords;
+    draw_letter_dsc.color = dsc->color;
+    draw_letter_dsc.rotation = dsc->rotation;
+    draw_letter_dsc.g = &glyph_dsc;
+
+    /* Set letter outline stroke attributes */
+    draw_letter_dsc.outline_stroke_width = dsc->outline_stroke_width;
+    draw_letter_dsc.outline_stroke_opa = dsc->outline_stroke_opa;
+    draw_letter_dsc.outline_stroke_color = dsc->outline_stroke_color;
+
+    lv_draw_fill_dsc_t fill_dsc;
+    lv_draw_fill_dsc_init(&fill_dsc);
+    fill_dsc.opa = dsc->opa;
+    int32_t underline_width = font->underline_thickness ? font->underline_thickness : 1;
+    int32_t line_start_x;
+    uint32_t next_char_offset;
+    uint32_t recolor_command_start_index = 0;
+    int32_t letter_w;
+
+    cmd_state_t recolor_cmd_state = RECOLOR_CMD_STATE_WAIT_FOR_PARAMETER;
+    lv_color_t recolor = lv_color_black(); /* Holds the selected color inside the recolor command */
+    uint8_t is_first_space_after_cmd = 0;
+
+    /*Write out all lines*/
+    while(remaining_len && dsc->text[line_start] != '\0') {
+        pos.x += x_ofs;
+        line_start_x = pos.x;
+
+        /*Write all letter of a line*/
+        next_char_offset = 0;
+#if LV_USE_BIDI
+        size_t bidi_size = line_end - line_start;
+        char * bidi_txt = lv_malloc(bidi_size + 1);
+        LV_ASSERT_MALLOC(bidi_txt);
+
+        /**
+          * has_bided = 1: already executed lv_bidi_process_paragraph.
+          * has_bided = 0: has not been executed lv_bidi_process_paragraph.*/
+        if(dsc->has_bided) {
+            lv_memcpy(bidi_txt, &dsc->text[line_start], bidi_size);
+        }
+        else {
+            lv_bidi_process_paragraph(dsc->text + line_start, bidi_txt, bidi_size, base_dir, NULL, 0);
+        }
+#else
+        const char * bidi_txt = dsc->text + line_start;
+#endif
+
+        while(next_char_offset < remaining_len && next_char_offset < line_end - line_start) {
+            uint32_t logical_char_pos = 0;
+
+            /* Check if the text selection is enabled */
+            if(sel_start != LV_DRAW_LABEL_NO_TXT_SEL && sel_end != LV_DRAW_LABEL_NO_TXT_SEL) {
+#if LV_USE_BIDI
+                if(dsc->has_bided) {
+                    logical_char_pos = lv_text_encoded_get_char_id(dsc->text, line_start + next_char_offset);
+                }
+                else {
+                    logical_char_pos = lv_text_encoded_get_char_id(dsc->text, line_start);
+                    uint32_t c_idx = lv_text_encoded_get_char_id(bidi_txt, next_char_offset);
+                    logical_char_pos += lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, base_dir, c_idx, NULL);
+                }
+#else
+                logical_char_pos = lv_text_encoded_get_char_id(dsc->text, line_start + next_char_offset);
+#endif
+            }
+
+            uint32_t letter;
+            uint32_t letter_next;
+            lv_text_encoded_letter_next_2(bidi_txt, &letter, &letter_next, &next_char_offset);
+
+            /* If recolor is enabled */
+            if((dsc->flag & LV_TEXT_FLAG_RECOLOR) != 0) {
+
+                if(letter == (uint32_t)LV_TXT_COLOR_CMD[0]) {
+                    /* Handle the recolor command marker depending of the current recolor state */
+
+                    if(recolor_cmd_state == RECOLOR_CMD_STATE_WAIT_FOR_PARAMETER) {
+                        recolor_command_start_index = next_char_offset;
+                        recolor_cmd_state = RECOLOR_CMD_STATE_PARAMETER;
+                        continue;
+                    }
+                    /*Other start char in parameter escaped cmd. char*/
+                    else if(recolor_cmd_state == RECOLOR_CMD_STATE_PARAMETER) {
+                        recolor_cmd_state = RECOLOR_CMD_STATE_WAIT_FOR_PARAMETER;
+                    }
+                    /* If letter is LV_TXT_COLOR_CMD and we were in the CMD_STATE_IN then the recolor close marked has been found */
+                    else if(recolor_cmd_state == RECOLOR_CMD_STATE_TEXT_INPUT) {
+                        recolor_cmd_state = RECOLOR_CMD_STATE_WAIT_FOR_PARAMETER;
+                        continue;
+                    }
+                }
+
+                /* Find the first space (aka ' ') after the recolor command parameter, we need to skip rendering it */
+                if((recolor_cmd_state == RECOLOR_CMD_STATE_PARAMETER) && (letter == ' ') && (is_first_space_after_cmd == 0)) {
+                    is_first_space_after_cmd = 1;
+                }
+                else {
+                    is_first_space_after_cmd = 0;
+                }
+
+                /* Skip the color parameter and wait the space after it
+                 * Once we have reach the space ' ', then we will extract the color information
+                 * and store it into the recolor variable */
+                if(recolor_cmd_state == RECOLOR_CMD_STATE_PARAMETER) {
+                    /* Not an space? Continue with the next character */
+                    if(letter != ' ') {
+                        continue;
+                    }
+
+                    /*Get the recolor parameter*/
+                    if((next_char_offset - recolor_command_start_index) == LABEL_RECOLOR_PAR_LENGTH + 1) {
+                        /* Temporary buffer to hold the recolor information */
+                        char buf[LABEL_RECOLOR_PAR_LENGTH + 1];
+                        lv_memcpy(buf, &bidi_txt[recolor_command_start_index], LABEL_RECOLOR_PAR_LENGTH);
+                        buf[LABEL_RECOLOR_PAR_LENGTH] = '\0';
+
+                        uint8_t r, g, b;
+                        r = (hex_char_to_num(buf[0]) << 4) + hex_char_to_num(buf[1]);
+                        g = (hex_char_to_num(buf[2]) << 4) + hex_char_to_num(buf[3]);
+                        b = (hex_char_to_num(buf[4]) << 4) + hex_char_to_num(buf[5]);
+
+                        recolor = lv_color_make(r, g, b);
+                    }
+                    else {
+                        recolor.red = dsc->color.red;
+                        recolor.blue = dsc->color.blue;
+                        recolor.green = dsc->color.green;
+                    }
+
+                    /*After the parameter the text is in the command*/
+                    recolor_cmd_state = RECOLOR_CMD_STATE_TEXT_INPUT;
+                }
+
+                /* Don't draw the first space after the recolor command */
+                if(is_first_space_after_cmd) {
+                    continue;
+                }
+            }
+
+            /* If we're in the CMD_STATE_IN state then we need to subtract the recolor command length */
+            if(((dsc->flag & LV_TEXT_FLAG_RECOLOR) != 0) && (recolor_cmd_state == RECOLOR_CMD_STATE_TEXT_INPUT)) {
+                logical_char_pos -= (LABEL_RECOLOR_PAR_LENGTH + 1);
+            }
+
+            lv_font_get_glyph_dsc(font, &glyph_dsc, letter, letter_next);
+            letter_w = lv_text_is_marker(letter) ? 0 : glyph_dsc.adv_w;
+
+            /*Always set the bg_coordinates for placeholder drawing*/
+            bg_coords.x1 = pos.x - dsc->letter_space / 2;
+            bg_coords.y1 = pos.y;
+            bg_coords.x2 = pos.x + letter_w - 1 + (dsc->letter_space + 1) / 2;
+            bg_coords.y2 = pos.y + line_height - 1;
+
+            if(next_char_offset >= line_end - line_start) {
+                if(dsc->decor & LV_TEXT_DECOR_UNDERLINE) {
+                    lv_area_t fill_area;
+                    fill_area.x1 = line_start_x;
+                    fill_area.x2 = pos.x + letter_w - 1;
+                    fill_area.y1 = pos.y + font->line_height - font->base_line - font->underline_position;
+                    fill_area.y2 = fill_area.y1 + underline_width - 1;
+
+                    fill_dsc.color = dsc->color;
+                    cb(t, NULL, &fill_dsc, &fill_area);
+                }
+                if(dsc->decor & LV_TEXT_DECOR_STRIKETHROUGH) {
+                    lv_area_t fill_area;
+                    fill_area.x1 = line_start_x;
+                    fill_area.x2 = pos.x + letter_w - 1;
+                    fill_area.y1 = pos.y + (font->line_height - font->base_line) * 2 / 3 + font->underline_thickness / 2;
+                    fill_area.y2 = fill_area.y1 + underline_width - 1;
+
+                    fill_dsc.color = dsc->color;
+                    cb(t, NULL, &fill_dsc, &fill_area);
+                }
+            }
+
+            /* Handle text selection */
+            if(sel_start != LV_DRAW_LABEL_NO_TXT_SEL && sel_end != LV_DRAW_LABEL_NO_TXT_SEL
+               && logical_char_pos >= sel_start && logical_char_pos < sel_end) {
+                draw_letter_dsc.color = dsc->sel_color;
+                fill_dsc.color = dsc->sel_bg_color;
+                cb(t, NULL, &fill_dsc, &bg_coords);
+            }
+            else if(recolor_cmd_state == RECOLOR_CMD_STATE_TEXT_INPUT) {
+                draw_letter_dsc.color = recolor;
+            }
+            else {
+                draw_letter_dsc.color = dsc->color;
+            }
+
+            lv_draw_unit_draw_letter(t, &draw_letter_dsc, &pos, font, letter, cb);
+
+            if(letter_w > 0) {
+                pos.x += letter_w + dsc->letter_space;
+            }
+        }
+
+#if LV_USE_BIDI
+        lv_free(bidi_txt);
+        bidi_txt = NULL;
+#endif
+
+        lv_text_attributes_t text_attributes = {0};
+        text_attributes.letter_space = dsc->letter_space;
+        text_attributes.text_flags = dsc->flag;
+        text_attributes.max_width = w;
+
+        /*Go to next line*/
+        remaining_len -= line_end - line_start;
+        line_start = line_end;
+        if(remaining_len) {
+            line_end += lv_text_get_next_line(&dsc->text[line_start], remaining_len, font, NULL, &text_attributes);
+        }
+
+        pos.x = coords->x1;
+        /*Align to middle*/
+        if(align == LV_TEXT_ALIGN_CENTER) {
+            line_width =
+                lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, &text_attributes);
+
+            pos.x += (lv_area_get_width(coords) - line_width) / 2;
+        }
+        /*Align to the right*/
+        else if(align == LV_TEXT_ALIGN_RIGHT) {
+            line_width =
+                lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, &text_attributes);
+            pos.x += lv_area_get_width(coords) - line_width;
+        }
+
+        /*Go the next line position*/
+        pos.y += line_height;
+
+        if(pos.y > t->clip_area.y2) break;
+    }
+
+    if(draw_letter_dsc._draw_buf) lv_draw_buf_destroy(draw_letter_dsc._draw_buf);
+
+    LV_ASSERT_MEM_INTEGRITY();
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Convert a hexadecimal characters to a number (0..15)
+ * @param hex Pointer to a hexadecimal character (0..9, A..F)
+ * @return the numerical value of `hex` or 0 on error
+ */
+static uint8_t hex_char_to_num(char hex)
+{
+    if(hex >= '0' && hex <= '9') return hex - '0';
+    if(hex >= 'a') hex -= 'a' - 'A'; /*Convert to upper case*/
+    return 'A' <= hex && hex <= 'F' ? hex - 'A' + 10 : 0;
+}
+
+void lv_draw_unit_draw_letter(lv_draw_task_t * t, lv_draw_glyph_dsc_t * dsc,  const lv_point_t * pos,
+                              const lv_font_t * font, uint32_t letter, lv_draw_glyph_cb_t cb)
+{
+    lv_font_glyph_dsc_t g;
+
+    if(lv_text_is_marker(letter)) /*Markers are valid letters but should not be rendered.*/
+        return;
+
+    LV_PROFILER_DRAW_BEGIN;
+    if(dsc->g == NULL) {
+        dsc->g = &g;
+        /*If the glyph dsc is not set then get it from the font*/
+        bool g_ret = lv_font_get_glyph_dsc(font, &g, letter, 0);
+        if(g_ret == false) {
+            /*Add warning if the dsc is not found*/
+            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%" LV_PRIX32, letter);
+        }
+    }
+    else {
+        /*If the glyph dsc is set then use it*/
+        g = *dsc->g;
+    }
+
+    /*Don't draw anything if the character is empty. E.g. space*/
+    if((g.box_h == 0) || (g.box_w == 0)) {
+        goto exit;
+    }
+
+    lv_area_t letter_coords;
+    letter_coords.x1 = pos->x + g.ofs_x;
+    letter_coords.x2 = letter_coords.x1 + g.box_w - 1;
+    letter_coords.y1 = pos->y + (font->line_height - font->base_line) - g.box_h - g.ofs_y;
+    letter_coords.y2 = letter_coords.y1 + g.box_h - 1;
+    lv_area_move(&letter_coords, -dsc->pivot.x, -dsc->pivot.y);
+
+    /*If the letter is completely out of mask don't draw it*/
+    if(lv_area_is_out(&letter_coords, &t->clip_area, 0) &&
+       dsc->bg_coords &&
+       lv_area_is_out(dsc->bg_coords, &t->clip_area, 0)) {
+        goto exit;
+    }
+
+    if(g.resolved_font) {
+        lv_draw_buf_t * draw_buf = NULL;
+        if(LV_FONT_GLYPH_FORMAT_NONE < g.format && g.format < LV_FONT_GLYPH_FORMAT_IMAGE) {
+            /*Only check draw buf for bitmap glyph*/
+            draw_buf = lv_draw_buf_reshape(dsc->_draw_buf, 0, g.box_w, g.box_h, LV_STRIDE_AUTO);
+            if(draw_buf == NULL) {
+                if(dsc->_draw_buf) lv_draw_buf_destroy(dsc->_draw_buf);
+
+                uint32_t h = LV_ROUND_UP(g.box_h, 32); /*Assume a larger size to avoid many reallocations*/
+                draw_buf = lv_draw_buf_create_ex(font_draw_buf_handlers, g.box_w, h, LV_COLOR_FORMAT_A8, LV_STRIDE_AUTO);
+                LV_ASSERT_MALLOC(draw_buf);
+                draw_buf->header.h = g.box_h;
+                dsc->_draw_buf = draw_buf;
+            }
+        }
+
+        dsc->format = g.format;
+
+        if(g.format == LV_FONT_GLYPH_FORMAT_VECTOR) {
+
+            /*Load the outline of the glyph, even if the function says bitmap*/
+            dsc->glyph_data = (void *) lv_font_get_glyph_bitmap(dsc->g, draw_buf);
+            dsc->format = dsc->glyph_data ? g.format : LV_FONT_GLYPH_FORMAT_NONE;
+        }
+    }
+    else {
+        dsc->format = LV_FONT_GLYPH_FORMAT_NONE;
+    }
+
+    dsc->letter_coords = &letter_coords;
+    cb(t, dsc, NULL, NULL);
+
+    lv_font_glyph_release_draw_data(dsc->g);
+
+exit:
+    if(dsc->g == &g) {
+        /* If the glyph was created locally, we don't need to keep it */
+        dsc->g = NULL;
+    }
+    LV_PROFILER_DRAW_END;
+}

components/easylvgl/lvgl9/src/draw/lv_draw_label.h

@@ -0,0 +1,252 @@
+/**
+ * @file lv_draw_label.h
+ *
+ */
+
+#ifndef LV_DRAW_LABEL_H
+#define LV_DRAW_LABEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+#include "lv_draw_rect.h"
+#include "../misc/lv_bidi.h"
+#include "../misc/lv_text.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_DRAW_LABEL_NO_TXT_SEL (0xFFFF)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**The text to draw*/
+    const char * text;
+
+    /**The size of the text*/
+    lv_point_t text_size;
+
+    /**The font to use. Fallback fonts are also handled.*/
+    const lv_font_t * font;
+
+    /**Color of the text*/
+    lv_color_t color;
+
+    /**Extra space between the lines*/
+    int32_t line_space;
+
+    /**Extra space between the characters*/
+    int32_t letter_space;
+
+    /**Offset the text with this value horizontally*/
+    int32_t ofs_x;
+
+    /**Offset the text with this value vertically*/
+    int32_t ofs_y;
+
+    /**Rotation of the letters in 0.1 degree unit*/
+    int32_t rotation;
+
+    /**The first characters index for selection (not byte index). `LV_DRAW_LABEL_NO_TXT_SEL` for no selection*/
+    uint32_t sel_start;
+
+    /**The last characters's index for selection (not byte index). `LV_DRAW_LABEL_NO_TXT_SEL` for no selection*/
+    uint32_t sel_end;
+
+    /**Color of the selected characters*/
+    lv_color_t sel_color;
+
+    /**Background color of the selected characters*/
+    lv_color_t sel_bg_color;
+
+    /**The number of characters to render. 0: means render until reaching the `\0` termination.*/
+    uint32_t text_length;
+
+    /**The alignment of the text `LV_TEXT_ALIGN_LEFT/RIGHT/CENTER`*/
+    lv_text_align_t align;
+
+    /**The base direction. Used when type setting Right-to-left (e.g. Arabic) texts*/
+    lv_base_dir_t bidi_dir;
+
+    /**Opacity of the text in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**Letter outline stroke opacity */
+    lv_opa_t outline_stroke_opa;
+
+    /**Text decoration, e.g. underline*/
+    lv_text_decor_t decor : 3;
+
+    /**Some flags to control type setting*/
+    lv_text_flag_t flag : 5;
+
+    /**1: malloc a buffer and copy `text` there.
+     * 0: `text` will be valid during rendering.*/
+    uint8_t text_local : 1;
+
+    /**Indicate that the text is constant and its pointer can be safely saved e.g. in a cache.*/
+    uint8_t text_static : 1;
+
+    /**1: already executed lv_bidi_process_paragraph.
+     * 0: has not been executed lv_bidi_process_paragraph.*/
+    uint8_t has_bided : 1;
+
+    /**Pointer to an externally stored struct where some data can be cached to speed up rendering*/
+    lv_draw_label_hint_t * hint;
+
+    /* Properties of the letter outlines */
+    lv_color_t outline_stroke_color;
+    int32_t outline_stroke_width;
+
+} lv_draw_label_dsc_t;
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    uint32_t unicode;
+    const lv_font_t * font;
+    lv_color_t color;
+
+    int32_t rotation;
+    int32_t scale_x;
+    int32_t scale_y;
+    int32_t skew_x;
+    int32_t skew_y;
+    lv_point_t pivot;
+
+    lv_opa_t opa;
+    lv_text_decor_t decor : 3;
+    lv_blend_mode_t blend_mode : 4;
+
+    /* Properties of the letter outlines */
+    lv_opa_t outline_stroke_opa;
+    int32_t outline_stroke_width;
+    lv_color_t outline_stroke_color;
+
+} lv_draw_letter_dsc_t;
+
+/**
+ * Passed as a parameter to `lv_draw_label_iterate_characters` to
+ * draw the characters one by one
+ * @param t             pointer to a draw task
+ * @param dsc           pointer to `lv_draw_glyph_dsc_t` to describe the character to draw
+ *                      if NULL don't draw character
+ * @param fill_dsc      pointer to a fill descriptor to draw a background for the character or
+ *                      underline or strike through
+ *                      if NULL do not fill anything
+ * @param fill_area     the area to fill
+ *                      if NULL do not fill anything
+ */
+typedef void(*lv_draw_glyph_cb_t)(lv_draw_task_t * t, lv_draw_glyph_dsc_t * dsc, lv_draw_fill_dsc_t * fill_dsc,
+                                  const lv_area_t * fill_area);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_letter_dsc_init(lv_draw_letter_dsc_t * dsc);
+
+/**
+ * Initialize a label draw descriptor
+ * @param dsc       pointer to a draw descriptor
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc);
+
+/**
+ * Try to get a label draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_LABEL
+ */
+lv_draw_label_dsc_t * lv_draw_task_get_label_dsc(lv_draw_task_t * task);
+
+/**
+ * Initialize a glyph draw descriptor.
+ * Used internally.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_glyph_dsc_init(lv_draw_glyph_dsc_t * dsc);
+
+/**
+ * Create a draw task to render a text
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to draw descriptor
+ * @param coords        coordinates of the character
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_label(lv_layer_t * layer, const lv_draw_label_dsc_t * dsc,
+                                               const lv_area_t * coords);
+
+/**
+ * Create a draw task to render a single character
+ * @param layer          pointer to a layer
+ * @param dsc            pointer to draw descriptor
+ * @param point          position of the label
+ * @param unicode_letter the letter to draw
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_character(lv_layer_t * layer, lv_draw_label_dsc_t * dsc,
+                                                   const lv_point_t * point, uint32_t unicode_letter);
+
+/**
+ * Draw a single letter
+ * @param layer          pointer to a layer
+ * @param dsc            pointer to draw descriptor
+ * @param point          position of the label
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_letter(lv_layer_t * layer, lv_draw_letter_dsc_t * dsc,
+                                                const lv_point_t * point);
+
+/**
+ * Should be used during rendering the characters to get the position and other
+ * parameters of the characters
+ * @param t             pointer to a draw task
+ * @param dsc           pointer to draw descriptor
+ * @param coords        coordinates of the label
+ * @param cb            a callback to call to draw each glyphs one by one
+ */
+void lv_draw_label_iterate_characters(lv_draw_task_t * t, const lv_draw_label_dsc_t * dsc,
+                                      const lv_area_t * coords, lv_draw_glyph_cb_t cb);
+
+/**
+ * @brief Draw a single letter using the provided draw unit, glyph descriptor, position, font, and callback.
+ *
+ * This function is responsible for rendering a single character from a text string,
+ * applying the necessary styling described by the glyph descriptor (`dsc`). It handles
+ * the retrieval of the glyph's description, checks its visibility within the clipping area,
+ * and invokes the callback (`cb`) to render the glyph at the specified position (`pos`)
+ * using the given font (`font`).
+ *
+ * @param t             Pointer to the drawing task.
+ * @param dsc           Pointer to the descriptor containing styling for the glyph to be drawn.
+ * @param pos           Pointer to the point coordinates where the letter should be drawn.
+ * @param font          Pointer to the font containing the glyph.
+ * @param letter        The Unicode code point of the letter to be drawn.
+ * @param cb            Callback function to execute the actual rendering of the glyph.
+ */
+void lv_draw_unit_draw_letter(lv_draw_task_t * t, lv_draw_glyph_dsc_t * dsc,  const lv_point_t * pos,
+                              const lv_font_t * font, uint32_t letter, lv_draw_glyph_cb_t cb);
+
+/***********************
+ * GLOBAL VARIABLES
+ ***********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LABEL_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_label_private.h

@@ -0,0 +1,74 @@
+/**
+ * @file lv_draw_label_private.h
+ *
+ */
+
+#ifndef LV_DRAW_LABEL_PRIVATE_H
+#define LV_DRAW_LABEL_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_label.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/** Store some info to speed up drawing of very large texts
+ * It takes a lot of time to get the first visible character because
+ * all the previous characters needs to be checked to calculate the positions.
+ * This structure stores an earlier (e.g. at -1000 px) coordinate and the index of that line.
+ * Therefore the calculations can start from here.*/
+struct _lv_draw_label_hint_t {
+    /** Index of the line at `y` coordinate*/
+    int32_t line_start;
+
+    /** Give the `y` coordinate of the first letter at `line start` index. Relative to the label's coordinates*/
+    int32_t y;
+
+    /** The 'y1' coordinate of the label when the hint was saved.
+     * Used to invalidate the hint if the label has moved too much.*/
+    int32_t coord_y;
+};
+
+struct _lv_draw_glyph_dsc_t {
+    /** Depends on `format` field, it could be image source or draw buf of bitmap or vector data. */
+    const void * glyph_data;
+    lv_font_glyph_format_t format;
+    const lv_area_t * letter_coords;
+    const lv_area_t * bg_coords;
+    lv_font_glyph_dsc_t * g;
+    lv_color_t color;
+    lv_opa_t opa;
+    lv_color_t outline_stroke_color;
+    lv_opa_t outline_stroke_opa;
+    int32_t outline_stroke_width;
+    int32_t rotation;
+    lv_point_t pivot;          /**< Rotation pivot point associated with total glyph including line_height */
+    lv_draw_buf_t * _draw_buf; /**< a shared draw buf for get_bitmap, do not use it directly, use glyph_data instead */
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LABEL_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_line.c

@@ -0,0 +1,76 @@
+/**
+ * @file lv_draw_line.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_private.h"
+#include "../core/lv_refr.h"
+#include "../misc/lv_math.h"
+#include "../misc/lv_types.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_line_dsc_t));
+    dsc->width = 1;
+    dsc->opa = LV_OPA_COVER;
+    dsc->color = lv_color_black();
+    dsc->base.dsc_size = sizeof(lv_draw_line_dsc_t);
+}
+
+lv_draw_line_dsc_t * lv_draw_task_get_line_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_LINE ? (lv_draw_line_dsc_t *)task->draw_dsc : NULL;
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_line(lv_layer_t * layer, const lv_draw_line_dsc_t * dsc)
+{
+    if(dsc->width == 0) return;
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_area_t a;
+    a.x1 = (int32_t)LV_MIN(dsc->p1.x, dsc->p2.x) - dsc->width;
+    a.x2 = (int32_t)LV_MAX(dsc->p1.x, dsc->p2.x) + dsc->width;
+    a.y1 = (int32_t)LV_MIN(dsc->p1.y, dsc->p2.y) - dsc->width;
+    a.y2 = (int32_t)LV_MAX(dsc->p1.y, dsc->p2.y) + dsc->width;
+
+    lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LINE);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

components/easylvgl/lvgl9/src/draw/lv_draw_line.h

@@ -0,0 +1,95 @@
+/**
+ * @file lv_draw_line.h
+ *
+ */
+
+#ifndef LV_DRAW_LINE_H
+#define LV_DRAW_LINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**The first point of the line. If `LV_USE_FLOAT` is enabled float number can be also used*/
+    lv_point_precise_t p1;
+
+    /**The second point of the line. If `LV_USE_FLOAT` is enabled float number can be also used*/
+    lv_point_precise_t p2;
+
+    /**The color of the line*/
+    lv_color_t color;
+
+    /**The width (thickness) of the line*/
+    int32_t width;
+
+    /** The length of a dash (0: don't dash)*/
+    int32_t dash_width;
+
+    /** The length of the gaps between dashes (0: don't dash)*/
+    int32_t dash_gap;
+
+    /**Opacity of the line in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**Make the line start rounded*/
+    uint8_t round_start : 1;
+
+    /**Make the line end rounded*/
+    uint8_t round_end   : 1;
+
+    /**1: Do not bother with line ending (if it's not visible for any reason) */
+    uint8_t raw_end     : 1;
+} lv_draw_line_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a line draw descriptor
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc);
+
+/**
+ * Try to get a line draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_LINE
+ */
+lv_draw_line_dsc_t * lv_draw_task_get_line_dsc(lv_draw_task_t * task);
+
+/**
+ * Create a line draw task
+ * @param layer     pointer to a layer
+ * @param dsc       pointer to an initialized `lv_draw_line_dsc_t` variable
+ */
+void lv_draw_line(lv_layer_t * layer, const lv_draw_line_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LINE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_mask.c

@@ -0,0 +1,79 @@
+/**
+ * @file lv_draw_mask.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_mask_private.h"
+#include "lv_draw_private.h"
+#include "../core/lv_refr.h"
+#include "../misc/lv_math.h"
+#include "../misc/lv_types.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect_dsc_init(lv_draw_mask_rect_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_mask_rect_dsc_t));
+}
+
+lv_draw_mask_rect_dsc_t * lv_draw_task_get_mask_rect_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_MASK_RECTANGLE ? (lv_draw_mask_rect_dsc_t *)task->draw_dsc : NULL;
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect(lv_layer_t * layer, const lv_draw_mask_rect_dsc_t * dsc)
+{
+    if(!lv_color_format_has_alpha(layer->color_format)) {
+        LV_LOG_WARN("Only layers with alpha channel can be masked");
+        return;
+    }
+    LV_PROFILER_DRAW_BEGIN;
+
+    lv_draw_task_t * t = lv_draw_add_task(layer, &layer->buf_area, LV_DRAW_TASK_TYPE_MASK_RECTANGLE);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_dsc_base_t * base_dsc = t->draw_dsc;
+    base_dsc->layer = layer;
+
+    if(base_dsc->obj && lv_obj_has_flag(base_dsc->obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS)) {
+        /*Disable sending LV_EVENT_DRAW_TASK_ADDED first to avoid triggering recursive
+         *event calls due draw task adds in the event*/
+        lv_obj_remove_flag(base_dsc->obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS);
+        lv_obj_send_event(dsc->base.obj, LV_EVENT_DRAW_TASK_ADDED, t);
+        lv_obj_add_flag(base_dsc->obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS);
+    }
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

components/easylvgl/lvgl9/src/draw/lv_draw_mask.h

@@ -0,0 +1,56 @@
+/**
+ * @file lv_draw_mask.h
+ *
+ */
+
+#ifndef LV_DRAW_MASK_H
+#define LV_DRAW_MASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../misc/lv_color.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a rectangle mask draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_mask_rect_dsc_init(lv_draw_mask_rect_dsc_t * dsc);
+
+/**
+ * Try to get a rectangle mask draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_MASK_RECTANGLE
+ */
+lv_draw_mask_rect_dsc_t * lv_draw_task_get_mask_rect_dsc(lv_draw_task_t * task);
+
+/**
+ * Create a draw task to mask a rectangle from the buffer
+ * @param layer     pointer to a layer
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_mask_rect(lv_layer_t * layer, const lv_draw_mask_rect_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_MASK_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_mask_private.h

@@ -0,0 +1,58 @@
+/**
+ * @file lv_draw_mask_private.h
+ *
+ */
+
+#ifndef LV_DRAW_MASK_PRIVATE_H
+#define LV_DRAW_MASK_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_mask.h"
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+struct _lv_draw_mask_rect_dsc_t {
+    lv_draw_dsc_base_t base;
+
+    /**The area t mask.*/
+    lv_area_t area;
+
+    /**The radius of masking*/
+    int32_t radius;
+
+    /**0: clear the content out of the `area`.
+     * 1: don't touch the area out of `area`*/
+    uint32_t keep_outside : 1;
+};
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_MASK_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_private.h

@@ -0,0 +1,210 @@
+/**
+ * @file lv_draw_private.h
+ *
+ */
+
+/**
+ * Modified by NXP in 2024
+ */
+
+#ifndef LV_DRAW_PRIVATE_H
+#define LV_DRAW_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw.h"
+#include "../osal/lv_os_private.h"
+#include "../misc/cache/lv_cache.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_draw_task_t {
+    lv_draw_task_t * next;
+
+    lv_draw_task_type_t type;
+
+    /**
+     * The area where to draw
+     */
+    lv_area_t area;
+
+    /**
+     * The real draw area. E.g. for shadow, outline, or transformed images it's different from `area`
+     */
+    lv_area_t _real_area;
+
+    /** The original area which is updated*/
+    lv_area_t clip_area_original;
+
+    /**
+     * The clip area of the layer is saved here when the draw task is created.
+     * As the clip area of the layer can be changed as new draw tasks are added its current value needs to be saved.
+     * Therefore during drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.
+     */
+    lv_area_t clip_area;
+    lv_layer_t * target_layer;
+
+#if LV_DRAW_TRANSFORM_USE_MATRIX
+    /** Transform matrix to be applied when rendering the layer */
+    lv_matrix_t matrix;
+#endif
+
+    /* Reference to the draw unit for debug or draw context purposes */
+    lv_draw_unit_t * draw_unit;
+
+    volatile int state;              /** int instead of lv_draw_task_state_t to be sure its atomic */
+
+    void * draw_dsc;
+
+    /** Opacity of the layer */
+    lv_opa_t opa;
+
+    /**
+     * The ID of the draw_unit which should take this task
+     */
+    uint8_t preferred_draw_unit_id;
+
+    /**
+     * Set to which extent `preferred_draw_unit_id` is good at this task.
+     * 80: means 20% better (faster) than software rendering
+     * 100: the default value
+     * 110: means 10% worse (slower) than software rendering
+     */
+    uint8_t preference_score;
+
+};
+
+struct _lv_draw_mask_t {
+    void * user_data;
+};
+
+struct _lv_draw_unit_t {
+    lv_draw_unit_t * next;
+
+    /**
+     * Name and ID of the draw unit, for debugging purposes only.
+     */
+    const char * name;
+    int32_t idx;
+
+    /**
+     * Called to try to assign a draw task to itself.
+     * `lv_draw_get_next_available_task` can be used to get an independent draw task.
+     * A draw task should be assign only if the draw unit can draw it too
+     * @param draw_unit     pointer to the draw unit
+     * @param layer         pointer to a layer on which the draw task should be drawn
+     * @return              >=0:    The number of taken draw task:
+     *                                  0 means the task has not yet been completed.
+     *                                  1 means a new task has been accepted.
+     *                      -1:     The draw unit wanted to work on a task but couldn't do that
+     *                              due to some errors (e.g. out of memory).
+     *                              It signals that LVGL should call the dispatcher later again
+     *                              to let draw unit try to start the rendering again.
+     */
+    int32_t (*dispatch_cb)(lv_draw_unit_t * draw_unit, lv_layer_t * layer);
+
+    /**
+     *
+     * @param draw_unit
+     * @param task
+     * @return
+     */
+    int32_t (*evaluate_cb)(lv_draw_unit_t * draw_unit, lv_draw_task_t * task);
+
+    /**
+     * Called to signal the unit to complete all tasks in order to return their ready status.
+     * This callback can be implemented in case of asynchronous task processing.
+     * Below is an example to show the difference between synchronous and asynchronous:
+     *
+     * Synchronous:
+     * LVGL thread              DRAW thread                 HW
+     *
+     * task1             -->    submit               -->    Receive task1
+     *                          wait_for_finish()
+     *                   <--    task1->state = READY <--    Complete task1
+     * task2             -->    submit               -->    Receive task2
+     *                          wait_for_finish()
+     *                          task2->state = READY <--    Complete task2
+     * task3             -->    submit               -->    Receive task3
+     *                          wait_for_finish()
+     *                   <--    task3->state = READY <--    Complete task3
+     * task4             -->    submit               -->    Receive task4
+     *                          wait_for_finish()
+     *                   <--    task4->state = READY <--    Complete task4
+     * NO MORE TASKS
+     *
+     *
+     * Asynchronous:
+     * LVGL thread              DRAW thread                 HW
+     *                                                      is IDLE
+     * task1             -->    queue task1
+     *                          submit               -->    Receive task1
+     * task2             -->    queue task2                 is BUSY (with task1)
+     * task3             -->    queue task3                 still BUSY (with task1)
+     * task4             -->    queue task4                 becomes IDLE
+     *                   <--    task1->state = READY <--    Complete task1
+     *                          submit               -->    Receive task2, task3, task4
+     * NO MORE TASKS
+     * wait_for_finish_cb()     wait_for_finish()
+     *                                               <--    Complete task2, task3, task4
+     *                   <--    task2->state = READY <--
+     *                   <--    task3->state = READY <--
+     *                   <--    task4->state = READY <--
+     *
+     * @param draw_unit
+     * @return
+     */
+    int32_t (*wait_for_finish_cb)(lv_draw_unit_t * draw_unit);
+
+    /**
+     * Called to delete draw unit.
+     * @param draw_unit
+     * @return
+     */
+    int32_t (*delete_cb)(lv_draw_unit_t * draw_unit);
+
+    /**
+     * Called when an event is sent to the draw unit.
+     * @param event pointer to the event descriptor
+     */
+    void (*event_cb)(lv_event_t * event);
+};
+
+typedef struct {
+    lv_draw_unit_t * unit_head;
+    uint32_t unit_cnt;
+    uint32_t used_memory_for_layers; /* measured as bytes */
+#if LV_USE_OS
+    lv_thread_sync_t sync;
+#else
+    volatile int dispatch_req;
+#endif
+    lv_mutex_t circle_cache_mutex;
+    bool task_running;
+} lv_draw_global_info_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_PRIVATE_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_rect.c

@@ -0,0 +1,346 @@
+/**
+ * @file lv_draw_rect.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_rect_private.h"
+#include "lv_draw_private.h"
+#include "../core/lv_obj.h"
+#include "../misc/lv_assert.h"
+#include "../misc/lv_text_private.h"
+#include "../core/lv_obj_event.h"
+#include "../stdlib/lv_string.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void LV_ATTRIBUTE_FAST_MEM lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(lv_draw_rect_dsc_t));
+    dsc->bg_color = lv_color_white();
+    dsc->bg_grad.stops[0].color = lv_color_white();
+    dsc->bg_grad.stops[1].color = lv_color_black();
+    dsc->bg_grad.stops[1].frac = 0xFF;
+    dsc->bg_grad.stops_count = 2;
+    dsc->border_color = lv_color_black();
+    dsc->shadow_color = lv_color_black();
+    dsc->bg_image_symbol_font = LV_FONT_DEFAULT;
+    dsc->bg_opa = LV_OPA_COVER;
+    dsc->bg_image_opa = LV_OPA_COVER;
+    dsc->outline_opa = LV_OPA_COVER;
+    dsc->border_opa = LV_OPA_COVER;
+    dsc->shadow_opa = LV_OPA_COVER;
+    dsc->border_side = LV_BORDER_SIDE_FULL;
+}
+
+void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(*dsc));
+    dsc->opa = LV_OPA_COVER;
+    dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
+}
+
+lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_FILL ? (lv_draw_fill_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_fill(lv_layer_t * layer, const lv_draw_fill_dsc_t * dsc, const lv_area_t * coords)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_FILL);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_border_dsc_init(lv_draw_border_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(*dsc));
+    dsc->opa = LV_OPA_COVER;
+    dsc->side = LV_BORDER_SIDE_FULL;
+    dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
+}
+
+lv_draw_border_dsc_t * lv_draw_task_get_border_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_BORDER ? (lv_draw_border_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_border(lv_layer_t * layer, const lv_draw_border_dsc_t * dsc, const lv_area_t * coords)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_box_shadow_dsc_init(lv_draw_box_shadow_dsc_t * dsc)
+{
+    lv_memzero(dsc, sizeof(*dsc));
+    dsc->opa = LV_OPA_COVER;
+    dsc->base.dsc_size = sizeof(lv_draw_box_shadow_dsc_t);
+}
+
+lv_draw_box_shadow_dsc_t * lv_draw_task_get_box_shadow_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_BOX_SHADOW ? (lv_draw_box_shadow_dsc_t *)task->draw_dsc : NULL;
+}
+
+void lv_draw_box_shadow(lv_layer_t * layer, const lv_draw_box_shadow_dsc_t * dsc, const lv_area_t * coords)
+{
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    LV_PROFILER_DRAW_BEGIN;
+    lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
+
+    lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
+
+    lv_draw_finalize_task_creation(layer, t);
+    LV_PROFILER_DRAW_END;
+}
+
+void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords)
+{
+
+    LV_PROFILER_DRAW_BEGIN;
+    bool has_shadow;
+    bool has_fill;
+    bool has_border;
+    bool has_outline;
+    bool has_bg_img;
+
+    if(dsc->shadow_width == 0 ||
+       dsc->shadow_opa <= LV_OPA_MIN ||
+       (dsc->shadow_width == 1 && dsc->shadow_spread <= 0 &&
+        dsc->shadow_offset_x == 0 && dsc->shadow_offset_y == 0)) {
+        has_shadow = false;
+    }
+    else {
+        has_shadow = true;
+    }
+
+    if(dsc->bg_opa <= LV_OPA_MIN) has_fill = false;
+    else has_fill = true;
+
+    if(dsc->bg_image_opa <= LV_OPA_MIN || dsc->bg_image_src == NULL) has_bg_img = false;
+    else has_bg_img = true;
+
+    if(dsc->border_opa <= LV_OPA_MIN
+       || dsc->border_width == 0
+       || dsc->border_post == true
+       || dsc->border_side == LV_BORDER_SIDE_NONE) has_border = false;
+    else has_border = true;
+
+    if(dsc->outline_opa <= LV_OPA_MIN || dsc->outline_width == 0) has_outline = false;
+    else has_outline = true;
+
+    bool bg_cover = true;
+    if(dsc->bg_opa < LV_OPA_COVER) bg_cover = false;
+    else if(dsc->bg_grad.dir != LV_GRAD_DIR_NONE) {
+        uint32_t s;
+        for(s = 0; s < dsc->bg_grad.stops_count; s++) {
+            if(dsc->bg_grad.stops[s].opa != LV_OPA_COVER) {
+                bg_cover = false;
+                break;
+            }
+        }
+    }
+
+    lv_draw_task_t * t;
+
+    /*Shadow*/
+    if(has_shadow) {
+        /*Check whether the shadow is visible*/
+        t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
+        lv_draw_box_shadow_dsc_t * shadow_dsc = t->draw_dsc;
+
+        lv_area_increase(&t->_real_area, dsc->shadow_spread, dsc->shadow_spread);
+        lv_area_increase(&t->_real_area, dsc->shadow_width, dsc->shadow_width);
+        lv_area_move(&t->_real_area, dsc->shadow_offset_x, dsc->shadow_offset_y);
+        shadow_dsc->base = dsc->base;
+        shadow_dsc->base.dsc_size = sizeof(lv_draw_box_shadow_dsc_t);
+        shadow_dsc->radius = dsc->radius;
+        shadow_dsc->color = dsc->shadow_color;
+        shadow_dsc->width = dsc->shadow_width;
+        shadow_dsc->spread = dsc->shadow_spread;
+        shadow_dsc->opa = dsc->shadow_opa;
+        shadow_dsc->ofs_x = dsc->shadow_offset_x;
+        shadow_dsc->ofs_y = dsc->shadow_offset_y;
+        shadow_dsc->bg_cover = bg_cover;
+        lv_draw_finalize_task_creation(layer, t);
+    }
+
+    /*Background*/
+    if(has_fill) {
+        lv_area_t bg_coords = *coords;
+        /*If the border fully covers make the bg area 1px smaller to avoid artifacts on the corners*/
+        if(dsc->border_width > 1 && dsc->border_opa >= LV_OPA_MAX && dsc->radius != 0) {
+            bg_coords.x1 += (dsc->border_side & LV_BORDER_SIDE_LEFT) ? 1 : 0;
+            bg_coords.y1 += (dsc->border_side & LV_BORDER_SIDE_TOP) ? 1 : 0;
+            bg_coords.x2 -= (dsc->border_side & LV_BORDER_SIDE_RIGHT) ? 1 : 0;
+            bg_coords.y2 -= (dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? 1 : 0;
+        }
+
+        t = lv_draw_add_task(layer, &bg_coords, LV_DRAW_TASK_TYPE_FILL);
+        lv_draw_fill_dsc_t * bg_dsc = t->draw_dsc;
+
+        lv_draw_fill_dsc_init(bg_dsc);
+        bg_dsc->base = dsc->base;
+        bg_dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
+        bg_dsc->radius = dsc->radius;
+        bg_dsc->color = dsc->bg_color;
+        bg_dsc->grad = dsc->bg_grad;
+        bg_dsc->opa = dsc->bg_opa;
+
+        lv_draw_finalize_task_creation(layer, t);
+    }
+
+    /*Background image*/
+    if(has_bg_img) {
+        lv_image_src_t src_type = lv_image_src_get_type(dsc->bg_image_src);
+        lv_result_t res = LV_RESULT_OK;
+        lv_image_header_t header;
+        if(src_type == LV_IMAGE_SRC_VARIABLE || src_type == LV_IMAGE_SRC_FILE) {
+            res  = lv_image_decoder_get_info(dsc->bg_image_src, &header);
+        }
+        else {
+            lv_memzero(&header, sizeof(header));
+
+            if(src_type == LV_IMAGE_SRC_UNKNOWN) {
+                res = LV_RESULT_INVALID;
+            }
+        }
+
+        if(res == LV_RESULT_OK) {
+            if(src_type == LV_IMAGE_SRC_VARIABLE || src_type == LV_IMAGE_SRC_FILE) {
+
+                if(dsc->bg_image_tiled) {
+                    t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_IMAGE);
+                }
+                else {
+                    lv_area_t a = {0, 0, header.w - 1, header.h - 1};
+                    lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
+                    t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_IMAGE);
+                }
+
+                lv_draw_image_dsc_t * bg_image_dsc = t->draw_dsc;
+
+                lv_draw_image_dsc_init(bg_image_dsc);
+                bg_image_dsc->base = dsc->base;
+                bg_image_dsc->base.dsc_size = sizeof(lv_draw_image_dsc_t);
+                bg_image_dsc->src = dsc->bg_image_src;
+                bg_image_dsc->opa = dsc->bg_image_opa;
+                bg_image_dsc->recolor = dsc->bg_image_recolor;
+                bg_image_dsc->recolor_opa = dsc->bg_image_recolor_opa;
+                bg_image_dsc->tile = dsc->bg_image_tiled;
+                bg_image_dsc->colorkey = dsc->bg_image_colorkey;
+                bg_image_dsc->header = header;
+                bg_image_dsc->clip_radius = dsc->radius;
+                bg_image_dsc->image_area = *coords;
+                lv_draw_finalize_task_creation(layer, t);
+            }
+            else {
+                lv_point_t s;
+
+                lv_text_attributes_t attributes = {0};
+                attributes.text_flags = LV_TEXT_FLAG_NONE;
+                attributes.max_width = LV_COORD_MAX;
+                attributes.line_space = 0;
+                attributes.letter_space = 0;
+
+                lv_text_get_size_attributes(&s, dsc->bg_image_src, dsc->bg_image_symbol_font, &attributes);
+
+                lv_area_t a = {0, 0, s.x - 1, s.y - 1};
+                lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
+                t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LABEL);
+
+                lv_draw_label_dsc_t * bg_label_dsc = t->draw_dsc;
+
+                lv_draw_label_dsc_init(bg_label_dsc);
+                bg_label_dsc->base = dsc->base;
+                bg_label_dsc->base.dsc_size = sizeof(lv_draw_label_dsc_t);
+                bg_label_dsc->color = dsc->bg_image_recolor;
+                bg_label_dsc->font = dsc->bg_image_symbol_font;
+                bg_label_dsc->text = dsc->bg_image_src;
+                t->type = LV_DRAW_TASK_TYPE_LABEL;
+                lv_draw_finalize_task_creation(layer, t);
+            }
+        }
+    }
+
+    /*Border*/
+    if(has_border) {
+        t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
+        lv_draw_border_dsc_t * border_dsc = t->draw_dsc;
+
+        border_dsc->base = dsc->base;
+        border_dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
+        border_dsc->radius = dsc->radius;
+        border_dsc->color = dsc->border_color;
+        border_dsc->opa = dsc->border_opa;
+        border_dsc->width = dsc->border_width;
+        border_dsc->side = dsc->border_side;
+        lv_draw_finalize_task_creation(layer, t);
+    }
+
+    /*Outline*/
+    if(has_outline) {
+        lv_area_t outline_coords = *coords;
+        lv_area_increase(&outline_coords, dsc->outline_width + dsc->outline_pad, dsc->outline_width + dsc->outline_pad);
+        t = lv_draw_add_task(layer, &outline_coords, LV_DRAW_TASK_TYPE_BORDER);
+        lv_draw_border_dsc_t * outline_dsc = t->draw_dsc;
+        lv_area_increase(&t->_real_area, dsc->outline_width, dsc->outline_width);
+        lv_area_increase(&t->_real_area, dsc->outline_pad, dsc->outline_pad);
+        outline_dsc->base = dsc->base;
+        outline_dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
+        outline_dsc->radius = dsc->radius == LV_RADIUS_CIRCLE ? LV_RADIUS_CIRCLE : dsc->radius + dsc->outline_width +
+                              dsc->outline_pad;
+        outline_dsc->color = dsc->outline_color;
+        outline_dsc->opa = dsc->outline_opa;
+        outline_dsc->width = dsc->outline_width;
+        outline_dsc->side = LV_BORDER_SIDE_FULL;
+        lv_draw_finalize_task_creation(layer, t);
+    }
+
+    LV_ASSERT_MEM_INTEGRITY();
+
+    LV_PROFILER_DRAW_END;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

components/easylvgl/lvgl9/src/draw/lv_draw_rect.h

@@ -0,0 +1,239 @@
+/**
+ * @file lv_draw_rect.h
+ *
+ */
+
+#ifndef LV_DRAW_RECT_H
+#define LV_DRAW_RECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+#include "../misc/lv_color.h"
+#include "../misc/lv_area.h"
+#include "../misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_RADIUS_CIRCLE        0x7FFF /**< A very big radius to always draw as circle*/
+LV_EXPORT_CONST_INT(LV_RADIUS_CIRCLE);
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    int32_t radius;
+
+    /*Background img*/
+    const void * bg_image_src;
+    const void * bg_image_symbol_font;
+    lv_color_t bg_image_recolor;
+    lv_opa_t bg_image_opa;
+    lv_opa_t bg_image_recolor_opa;
+    uint8_t bg_image_tiled;
+    /*Background*/
+    lv_opa_t bg_opa;
+    /*Border*/
+    lv_opa_t border_opa;
+    /*Outline */
+    lv_opa_t outline_opa;
+    /*Shadow*/
+    lv_opa_t shadow_opa;
+
+    /*Background*/
+    lv_color_t bg_color;        /**< First element of a gradient is a color, so it maps well here*/
+    lv_grad_dsc_t bg_grad;
+
+    const lv_image_colorkey_t * bg_image_colorkey;
+
+    /*Border*/
+    lv_color_t border_color;
+    int32_t border_width;
+    lv_border_side_t border_side : 5;
+    uint8_t border_post : 1; /*The border will be drawn later*/
+
+    /*Outline*/
+    lv_color_t outline_color;
+    int32_t outline_width;
+    int32_t outline_pad;
+
+    /*Shadow*/
+    lv_color_t shadow_color;
+    int32_t shadow_width;
+    int32_t shadow_offset_x;
+    int32_t shadow_offset_y;
+    int32_t shadow_spread;
+} lv_draw_rect_dsc_t;
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**Radius, LV_RADIUS_CIRCLE for max. radius */
+    int32_t radius;
+
+    /**Opacity in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**The color of the rectangle.
+     * If the gradient is set (grad.dir!=LV_GRAD_DIR_NONE) it's ignored. */
+    lv_color_t color;
+
+    /**Describe a gradient. If `grad.dir` is not `LV_GRAD_DIR_NONE` `color` will be ignored*/
+    lv_grad_dsc_t grad;
+} lv_draw_fill_dsc_t;
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**Radius, LV_RADIUS_CIRCLE for max. radius */
+    int32_t radius;
+
+    /**The color of the border. */
+    lv_color_t color;
+
+
+    /**The width of the border in pixels */
+    int32_t width;
+
+    /**Opacity in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**LV_BORDER_SIDE_NONE/LEFT/RIGHT/TOP/BOTTOM/FULL.
+     * LV_BORDER_SIDE_INTERNAL is an information for upper layers
+     * and shouldn't be used here. */
+    lv_border_side_t side : 5;
+
+} lv_draw_border_dsc_t;
+
+typedef struct {
+    lv_draw_dsc_base_t base;
+
+    /**Radius, LV_RADIUS_CIRCLE for max. radius */
+    int32_t radius;
+
+    /**Color of shadow */
+    lv_color_t color;
+
+    /**Width of the shadow. (radius of the blur)*/
+    int32_t width;
+
+    /**Make the rectangle larger with this value in all directions. Can be negative too. */
+    int32_t spread;
+
+    /**Offset the rectangle horizontally.*/
+    int32_t ofs_x;
+
+    /**Offset the rectangle vertically.*/
+    int32_t ofs_y;
+
+    /**Opacity in 0...255 range.
+     * LV_OPA_TRANSP, LV_OPA_10, LV_OPA_20, .. LV_OPA_COVER can be used as well*/
+    lv_opa_t opa;
+
+    /**Set `bg_cover` to 1 if the background will cover the shadow.
+     * It's a hint to the renderer about it might skip some masking.*/
+    uint8_t bg_cover    : 1;
+} lv_draw_box_shadow_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a rectangle draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc);
+
+/**
+ * Initialize a fill draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc);
+
+/**
+ * Try to get a fill draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_FILL
+ */
+lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task);
+
+/**
+ * Fill an area
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor variable
+ * @param coords        the coordinates of the rectangle
+ */
+void lv_draw_fill(lv_layer_t * layer, const lv_draw_fill_dsc_t * dsc, const lv_area_t * coords);
+
+/**
+ * Initialize a border draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_border_dsc_init(lv_draw_border_dsc_t * dsc);
+
+/**
+ * Try to get a border draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_BORDER
+ */
+lv_draw_border_dsc_t * lv_draw_task_get_border_dsc(lv_draw_task_t * task);
+
+/**
+ * Draw a border
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor variable
+ * @param coords        the coordinates of the rectangle
+ */
+void lv_draw_border(lv_layer_t * layer, const lv_draw_border_dsc_t * dsc, const lv_area_t * coords);
+
+/**
+ * Initialize a box shadow draw descriptor.
+ * @param dsc       pointer to a draw descriptor
+ */
+void lv_draw_box_shadow_dsc_init(lv_draw_box_shadow_dsc_t * dsc);
+
+/**
+ * Try to get a box shadow draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_BOX_SHADOW
+ */
+lv_draw_box_shadow_dsc_t * lv_draw_task_get_box_shadow_dsc(lv_draw_task_t * task);
+
+/**
+ * Draw a box shadow
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor variable
+ * @param coords        the coordinates of the rectangle
+ */
+void lv_draw_box_shadow(lv_layer_t * layer, const lv_draw_box_shadow_dsc_t * dsc, const lv_area_t * coords);
+
+/**
+ * The rectangle is a wrapper for fill, border, bg. image and box shadow.
+ * Internally fill, border, image and box shadow draw tasks will be created.
+ * @param layer         pointer to a layer
+ * @param dsc           pointer to an initialized draw descriptor variable
+ * @param coords        the coordinates of the rectangle
+ */
+void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_RECT_H*/

components/easylvgl/lvgl9/src/draw/lv_draw_rect_private.h

@@ -0,0 +1,39 @@
+/**
+ * @file lv_draw_rect_private.h
+ *
+ */
+
+#ifndef LV_DRAW_RECT_PRIVATE_H
+#define LV_DRAW_RECT_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_draw_rect.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_RECT_PRIVATE_H*/