Uploading the first files

include/liblvgl/extra/layouts/flex/lv_flex.h

@@ -0,0 +1,152 @@
+/**
+ * @file lv_flex.h
+ *
+ */
+
+#ifndef LV_FLEX_H
+#define LV_FLEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#if LV_USE_FLEX
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_OBJ_FLAG_FLEX_IN_NEW_TRACK   LV_OBJ_FLAG_LAYOUT_1
+LV_EXPORT_CONST_INT(LV_OBJ_FLAG_FLEX_IN_NEW_TRACK);
+
+#define _LV_FLEX_COLUMN        (1 << 0)
+#define _LV_FLEX_WRAP       (1 << 2)
+#define _LV_FLEX_REVERSE    (1 << 3)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Can't include lv_obj.h because it includes this header file*/
+struct _lv_obj_t;
+
+typedef enum {
+    LV_FLEX_ALIGN_START,
+    LV_FLEX_ALIGN_END,
+    LV_FLEX_ALIGN_CENTER,
+    LV_FLEX_ALIGN_SPACE_EVENLY,
+    LV_FLEX_ALIGN_SPACE_AROUND,
+    LV_FLEX_ALIGN_SPACE_BETWEEN,
+} lv_flex_align_t;
+
+typedef enum {
+    LV_FLEX_FLOW_ROW                 = 0x00,
+    LV_FLEX_FLOW_COLUMN              = _LV_FLEX_COLUMN,
+    LV_FLEX_FLOW_ROW_WRAP            = LV_FLEX_FLOW_ROW | _LV_FLEX_WRAP,
+    LV_FLEX_FLOW_ROW_REVERSE         = LV_FLEX_FLOW_ROW | _LV_FLEX_REVERSE,
+    LV_FLEX_FLOW_ROW_WRAP_REVERSE    = LV_FLEX_FLOW_ROW | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
+    LV_FLEX_FLOW_COLUMN_WRAP         = LV_FLEX_FLOW_COLUMN | _LV_FLEX_WRAP,
+    LV_FLEX_FLOW_COLUMN_REVERSE      = LV_FLEX_FLOW_COLUMN | _LV_FLEX_REVERSE,
+    LV_FLEX_FLOW_COLUMN_WRAP_REVERSE = LV_FLEX_FLOW_COLUMN | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
+} lv_flex_flow_t;
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+extern uint16_t LV_LAYOUT_FLEX;
+extern lv_style_prop_t LV_STYLE_FLEX_FLOW;
+extern lv_style_prop_t LV_STYLE_FLEX_MAIN_PLACE;
+extern lv_style_prop_t LV_STYLE_FLEX_CROSS_PLACE;
+extern lv_style_prop_t LV_STYLE_FLEX_TRACK_PLACE;
+extern lv_style_prop_t LV_STYLE_FLEX_GROW;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a flex layout the default values
+ * @param flex pointer to a flex layout descriptor
+ */
+void lv_flex_init(void);
+
+/**
+ * Set hot the item should flow
+ * @param flex pointer to a flex layout descriptor
+ * @param flow an element of `lv_flex_flow_t`.
+ */
+void lv_obj_set_flex_flow(lv_obj_t * obj, lv_flex_flow_t flow);
+
+/**
+ * Set how to place (where to align) the items and tracks
+ * @param flex pointer: to a flex layout descriptor
+ * @param main_place where to place the items on main axis (in their track). Any value of `lv_flex_align_t`.
+ * @param cross_place where to place the item in their track on the cross axis. `LV_FLEX_ALIGN_START/END/CENTER`
+ * @param track_place where to place the tracks in the cross direction. Any value of `lv_flex_align_t`.
+ */
+void lv_obj_set_flex_align(lv_obj_t * obj, lv_flex_align_t main_place, lv_flex_align_t cross_place,
+                           lv_flex_align_t track_cross_place);
+
+/**
+ * Sets the width or height (on main axis) to grow the object in order fill the free space
+ * @param obj pointer to an object. The parent must have flex layout else nothing will happen.
+ * @param grow a value to set how much free space to take proportionally to other growing items.
+ */
+void lv_obj_set_flex_grow(lv_obj_t * obj, uint8_t grow);
+
+void lv_style_set_flex_flow(lv_style_t * style, lv_flex_flow_t value);
+void lv_style_set_flex_main_place(lv_style_t * style, lv_flex_align_t value);
+void lv_style_set_flex_cross_place(lv_style_t * style, lv_flex_align_t value);
+void lv_style_set_flex_track_place(lv_style_t * style, lv_flex_align_t value);
+void lv_style_set_flex_grow(lv_style_t * style, uint8_t value);
+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);
+
+static inline lv_flex_flow_t lv_obj_get_style_flex_flow(const lv_obj_t * obj, uint32_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, uint32_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, uint32_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, uint32_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, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_FLEX_GROW);
+    return (uint8_t)v.num;
+}
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_FLEX*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_FLEX_H*/

include/liblvgl/extra/layouts/grid/lv_grid.h

@@ -0,0 +1,194 @@
+/**
+ * @file lv_grid.h
+ *
+ */
+
+#ifndef LV_GRID_H
+#define LV_GRID_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#if LV_USE_GRID
+
+/*********************
+ *      DEFINES
+ *********************/
+/**
+ * Can be used track size to make the track fill the free space.
+ * @param x how much space to take proportionally to other FR tracks
+ * @return a special track size
+ */
+#define LV_GRID_FR(x)          (LV_COORD_MAX - 100 + x)
+
+#define LV_GRID_CONTENT        (LV_COORD_MAX - 101)
+LV_EXPORT_CONST_INT(LV_GRID_CONTENT);
+
+#define LV_GRID_TEMPLATE_LAST  (LV_COORD_MAX)
+LV_EXPORT_CONST_INT(LV_GRID_TEMPLATE_LAST);
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Can't include lv_obj.h because it includes this header file*/
+struct _lv_obj_t;
+
+typedef enum {
+    LV_GRID_ALIGN_START,
+    LV_GRID_ALIGN_CENTER,
+    LV_GRID_ALIGN_END,
+    LV_GRID_ALIGN_STRETCH,
+    LV_GRID_ALIGN_SPACE_EVENLY,
+    LV_GRID_ALIGN_SPACE_AROUND,
+    LV_GRID_ALIGN_SPACE_BETWEEN,
+} lv_grid_align_t;
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+
+extern uint16_t LV_LAYOUT_GRID;
+extern lv_style_prop_t LV_STYLE_GRID_COLUMN_DSC_ARRAY;
+extern lv_style_prop_t LV_STYLE_GRID_COLUMN_ALIGN;
+extern lv_style_prop_t LV_STYLE_GRID_ROW_DSC_ARRAY;
+extern lv_style_prop_t LV_STYLE_GRID_ROW_ALIGN;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_COLUMN_POS;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_COLUMN_SPAN;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_X_ALIGN;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_ROW_POS;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_ROW_SPAN;
+extern lv_style_prop_t LV_STYLE_GRID_CELL_Y_ALIGN;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_grid_init(void);
+
+void lv_obj_set_grid_dsc_array(lv_obj_t * obj, const lv_coord_t col_dsc[], const lv_coord_t row_dsc[]);
+
+void lv_obj_set_grid_align(lv_obj_t * obj, lv_grid_align_t column_align, lv_grid_align_t row_align);
+
+/**
+ * Set the cell of an object. The object's parent needs to have grid layout, else nothing will happen
+ * @param obj pointer to an object
+ * @param column_align the vertical alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
+ * @param col_pos column ID
+ * @param col_span number of columns to take (>= 1)
+ * @param row_align the horizontal alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
+ * @param row_pos row ID
+ * @param row_span number of rows to take (>= 1)
+ */
+void lv_obj_set_grid_cell(lv_obj_t * obj, lv_grid_align_t column_align, uint8_t col_pos, uint8_t col_span,
+                          lv_grid_align_t row_align, uint8_t row_pos, uint8_t row_span);
+
+/**
+ * Just a wrapper to `LV_GRID_FR` for bindings.
+ */
+static inline lv_coord_t lv_grid_fr(uint8_t x)
+{
+    return LV_GRID_FR(x);
+}
+
+void lv_style_set_grid_row_dsc_array(lv_style_t * style, const lv_coord_t value[]);
+void lv_style_set_grid_column_dsc_array(lv_style_t * style, const lv_coord_t value[]);
+void lv_style_set_grid_row_align(lv_style_t * style, lv_grid_align_t value);
+void lv_style_set_grid_column_align(lv_style_t * style, lv_grid_align_t value);
+void lv_style_set_grid_cell_column_pos(lv_style_t * style, lv_coord_t value);
+void lv_style_set_grid_cell_column_span(lv_style_t * style, lv_coord_t value);
+void lv_style_set_grid_cell_row_pos(lv_style_t * style, lv_coord_t value);
+void lv_style_set_grid_cell_row_span(lv_style_t * style, lv_coord_t value);
+void lv_style_set_grid_cell_x_align(lv_style_t * style, lv_coord_t value);
+void lv_style_set_grid_cell_y_align(lv_style_t * style, lv_coord_t value);
+
+void lv_obj_set_style_grid_row_dsc_array(lv_obj_t * obj, const lv_coord_t value[], lv_style_selector_t selector);
+void lv_obj_set_style_grid_column_dsc_array(lv_obj_t * obj, const lv_coord_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_column_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, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_column_span(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_row_pos(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_row_span(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_x_align(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_grid_cell_y_align(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+
+static inline const lv_coord_t * lv_obj_get_style_grid_row_dsc_array(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_ROW_DSC_ARRAY);
+    return (const lv_coord_t *)v.ptr;
+}
+
+static inline const lv_coord_t * lv_obj_get_style_grid_column_dsc_array(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_COLUMN_DSC_ARRAY);
+    return (const lv_coord_t *)v.ptr;
+}
+
+static inline lv_grid_align_t lv_obj_get_style_grid_row_align(const lv_obj_t * obj, uint32_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 lv_grid_align_t lv_obj_get_style_grid_column_align(const lv_obj_t * obj, uint32_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 lv_coord_t lv_obj_get_style_grid_cell_column_pos(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_COLUMN_POS);
+    return (lv_coord_t)v.num;
+}
+
+static inline lv_coord_t lv_obj_get_style_grid_cell_column_span(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_COLUMN_SPAN);
+    return (lv_coord_t)v.num;
+}
+
+static inline lv_coord_t lv_obj_get_style_grid_cell_row_pos(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_ROW_POS);
+    return (lv_coord_t)v.num;
+}
+
+static inline lv_coord_t lv_obj_get_style_grid_cell_row_span(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_ROW_SPAN);
+    return (lv_coord_t)v.num;
+}
+
+static inline lv_coord_t lv_obj_get_style_grid_cell_x_align(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_X_ALIGN);
+    return (lv_coord_t)v.num;
+}
+
+static inline lv_coord_t lv_obj_get_style_grid_cell_y_align(const lv_obj_t * obj, uint32_t part)
+{
+    lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_GRID_CELL_Y_ALIGN);
+    return (lv_coord_t)v.num;
+}
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_GRID*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GRID_H*/

include/liblvgl/extra/layouts/lv_layouts.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_layouts.h
+ *
+ */
+
+#ifndef LV_LAYOUTS_H
+#define LV_LAYOUTS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "flex/lv_flex.h"
+#include "grid/lv_grid.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#if LV_USE_LOG && LV_LOG_TRACE_LAYOUT
+#  define LV_TRACE_LAYOUT(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+#  define LV_TRACE_LAYOUT(...)
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LAYOUTS_H*/

include/liblvgl/extra/libs/bmp/lv_bmp.h

@@ -0,0 +1,42 @@
+/**
+ * @file lv_bmp.h
+ *
+ */
+
+#ifndef LV_BMP_H
+#define LV_BMP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#if LV_USE_BMP
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_bmp_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_BMP*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_BMP_H*/

include/liblvgl/extra/libs/ffmpeg/lv_ffmpeg.h

@@ -0,0 +1,104 @@
+/**
+ * @file lv_ffmpeg.h
+ *
+ */
+#ifndef LV_FFMPEG_H
+#define LV_FFMPEG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+#if LV_USE_FFMPEG != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+struct ffmpeg_context_s;
+
+extern const lv_obj_class_t lv_ffmpeg_player_class;
+
+typedef struct {
+    lv_img_t img;
+    lv_timer_t * timer;
+    lv_img_dsc_t imgdsc;
+    bool auto_restart;
+    struct ffmpeg_context_s * ffmpeg_ctx;
+} lv_ffmpeg_player_t;
+
+typedef enum {
+    LV_FFMPEG_PLAYER_CMD_START,
+    LV_FFMPEG_PLAYER_CMD_STOP,
+    LV_FFMPEG_PLAYER_CMD_PAUSE,
+    LV_FFMPEG_PLAYER_CMD_RESUME,
+    _LV_FFMPEG_PLAYER_CMD_LAST
+} lv_ffmpeg_player_cmd_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Register FFMPEG image decoder
+ */
+void lv_ffmpeg_init(void);
+
+/**
+ * Get the number of frames contained in the file
+ * @param path image or video file name
+ * @return Number of frames, less than 0 means failed
+ */
+int lv_ffmpeg_get_frame_num(const char * path);
+
+/**
+ * Create ffmpeg_player object
+ * @param parent pointer to an object, it will be the parent of the new player
+ * @return pointer to the created ffmpeg_player
+ */
+lv_obj_t * lv_ffmpeg_player_create(lv_obj_t * parent);
+
+/**
+ * Set the path of the file to be played
+ * @param obj pointer to a ffmpeg_player object
+ * @param path video file path
+ * @return LV_RES_OK: no error; LV_RES_INV: can't get the info.
+ */
+lv_res_t lv_ffmpeg_player_set_src(lv_obj_t * obj, const char * path);
+
+/**
+ * Set command control video player
+ * @param obj pointer to a ffmpeg_player object
+ * @param cmd control commands
+ */
+void lv_ffmpeg_player_set_cmd(lv_obj_t * obj, lv_ffmpeg_player_cmd_t cmd);
+
+/**
+ * Set the video to automatically replay
+ * @param obj pointer to a ffmpeg_player object
+ * @param en true: enable the auto restart
+ */
+void lv_ffmpeg_player_set_auto_restart(lv_obj_t * obj, bool en);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_FFMPEG*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_FFMPEG_H*/

include/liblvgl/extra/libs/freetype/lv_freetype.h

@@ -0,0 +1,83 @@
+/**
+ * @file lv_freetype.h
+ *
+ */
+#ifndef LV_FREETYPE_H
+#define LV_FREETYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+#if LV_USE_FREETYPE
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef enum {
+    FT_FONT_STYLE_NORMAL = 0,
+    FT_FONT_STYLE_ITALIC = 1 << 0,
+    FT_FONT_STYLE_BOLD   = 1 << 1
+} LV_FT_FONT_STYLE;
+
+typedef struct {
+    const char * name;  /* The name of the font file */
+    const void * mem;   /* The pointer of the font file */
+    size_t mem_size;    /* The size of the memory */
+    lv_font_t * font;   /* point to lvgl font */
+    uint16_t weight;    /* font size */
+    uint16_t style;     /* font style */
+} lv_ft_info_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * init freetype library
+ * @param max_faces Maximum number of opened FT_Face objects managed by this cache instance. Use 0 for defaults.
+ * @param max_sizes Maximum number of opened FT_Size objects managed by this cache instance. Use 0 for defaults.
+ * @param max_bytes Maximum number of bytes to use for cached data nodes. Use 0 for defaults.
+ *                  Note that this value does not account for managed FT_Face and FT_Size objects.
+ * @return true on success, otherwise false.
+ */
+bool lv_freetype_init(uint16_t max_faces, uint16_t max_sizes, uint32_t max_bytes);
+
+/**
+ * Destroy freetype library
+ */
+void lv_freetype_destroy(void);
+
+/**
+ * Creates a font with info parameter specified.
+ * @param info See lv_ft_info_t for details.
+ *             when success, lv_ft_info_t->font point to the font you created.
+ * @return true on success, otherwise false.
+ */
+bool lv_ft_font_init(lv_ft_info_t * info);
+
+/**
+ * Destroy a font that has been created.
+ * @param font pointer to font.
+ */
+void lv_ft_font_destroy(lv_font_t * font);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_FREETYPE*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV_FREETYPE_H */

include/liblvgl/extra/libs/fsdrv/lv_fsdrv.h

@@ -0,0 +1,55 @@
+/**
+ * @file lv_fsdrv.h
+ *
+ */
+
+#ifndef LV_FSDRV_H
+#define LV_FSDRV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+#if LV_USE_FS_FATFS != '\0'
+void lv_fs_fatfs_init(void);
+#endif
+
+#if LV_USE_FS_STDIO != '\0'
+void lv_fs_stdio_init(void);
+#endif
+
+#if LV_USE_FS_POSIX != '\0'
+void lv_fs_posix_init(void);
+#endif
+
+#if LV_USE_FS_WIN32 != '\0'
+void lv_fs_win32_init(void);
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_FSDRV_H*/
+

include/liblvgl/extra/libs/gif/gifdec.h

@@ -0,0 +1,60 @@
+#ifndef GIFDEC_H
+#define GIFDEC_H
+
+#include <stdint.h>
+#include "liblvgl/misc/lv_fs.h"
+
+#if LV_USE_GIF
+
+typedef struct gd_Palette {
+    int size;
+    uint8_t colors[0x100 * 3];
+} gd_Palette;
+
+typedef struct gd_GCE {
+    uint16_t delay;
+    uint8_t tindex;
+    uint8_t disposal;
+    int input;
+    int transparency;
+} gd_GCE;
+
+
+
+typedef struct gd_GIF {
+    lv_fs_file_t fd;
+    const char * data;
+    uint8_t is_file;
+    uint32_t f_rw_p;
+    int32_t anim_start;
+    uint16_t width, height;
+    uint16_t depth;
+    uint16_t loop_count;
+    gd_GCE gce;
+    gd_Palette *palette;
+    gd_Palette lct, gct;
+    void (*plain_text)(
+        struct gd_GIF *gif, uint16_t tx, uint16_t ty,
+        uint16_t tw, uint16_t th, uint8_t cw, uint8_t ch,
+        uint8_t fg, uint8_t bg
+    );
+    void (*comment)(struct gd_GIF *gif);
+    void (*application)(struct gd_GIF *gif, char id[8], char auth[3]);
+    uint16_t fx, fy, fw, fh;
+    uint8_t bgindex;
+    uint8_t *canvas, *frame;
+} gd_GIF;
+
+gd_GIF * gd_open_gif_file(const char *fname);
+
+gd_GIF * gd_open_gif_data(const void *data);
+
+void gd_render_frame(gd_GIF *gif, uint8_t *buffer);
+
+int gd_get_frame(gd_GIF *gif);
+void gd_rewind(gd_GIF *gif);
+void gd_close_gif(gd_GIF *gif);
+
+#endif /*LV_USE_GIF*/
+
+#endif /* GIFDEC_H */

include/liblvgl/extra/libs/gif/lv_gif.h

@@ -0,0 +1,58 @@
+/**
+ * @file lv_gif.h
+ *
+ */
+
+#ifndef LV_GIF_H
+#define LV_GIF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lvgl.h"
+#if LV_USE_GIF
+
+#include "gifdec.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_img_t img;
+    gd_GIF * gif;
+    lv_timer_t * timer;
+    lv_img_dsc_t imgdsc;
+    uint32_t last_call;
+} lv_gif_t;
+
+extern const lv_obj_class_t lv_gif_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_gif_create(lv_obj_t * parent);
+void lv_gif_set_src(lv_obj_t * obj, const void * src);
+void lv_gif_restart(lv_obj_t * gif);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GIF*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_GIF_H*/

include/liblvgl/extra/libs/lv_libs.h

@@ -0,0 +1,46 @@
+/**
+ * @file lv_libs.h
+ *
+ */
+
+#ifndef LV_LIBS_H
+#define LV_LIBS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "bmp/lv_bmp.h"
+#include "fsdrv/lv_fsdrv.h"
+#include "png/lv_png.h"
+#include "gif/lv_gif.h"
+#include "qrcode/lv_qrcode.h"
+#include "sjpg/lv_sjpg.h"
+#include "freetype/lv_freetype.h"
+#include "rlottie/lv_rlottie.h"
+#include "ffmpeg/lv_ffmpeg.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LIBS_H*/

include/liblvgl/extra/libs/png/lv_png.h

@@ -0,0 +1,46 @@
+/**
+ * @file lv_png.h
+ *
+ */
+
+#ifndef LV_PNG_H
+#define LV_PNG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#if LV_USE_PNG
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Register the PNG decoder functions in LVGL
+ */
+void lv_png_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_PNG*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_PNG_H*/

include/liblvgl/extra/libs/qrcode/lv_qrcode.h

@@ -0,0 +1,69 @@
+/**
+ * @file lv_qrcode
+ *
+ */
+
+#ifndef LV_QRCODE_H
+#define LV_QRCODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+#if LV_USE_QRCODE
+
+/*********************
+ *      DEFINES
+ *********************/
+
+extern const lv_obj_class_t lv_qrcode_class;
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create an empty QR code (an `lv_canvas`) object.
+ * @param parent point to an object where to create the QR code
+ * @param size width and height of the QR code
+ * @param dark_color dark color of the QR code
+ * @param light_color light color of the QR code
+ * @return pointer to the created QR code object
+ */
+lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color);
+
+/**
+ * Set the data of a QR code object
+ * @param qrcode pointer to aQ code object
+ * @param data data to display
+ * @param data_len length of data in bytes
+ * @return LV_RES_OK: if no error; LV_RES_INV: on error
+ */
+lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len);
+
+/**
+ * DEPRECATED: Use normal lv_obj_del instead
+ * Delete a QR code object
+ * @param qrcode pointer to a QR code object
+ */
+void lv_qrcode_delete(lv_obj_t * qrcode);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_QRCODE*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_QRCODE_H*/

include/liblvgl/extra/libs/qrcode/qrcodegen.h

@@ -0,0 +1,319 @@
+/*
+ * QR Code generator library (C)
+ *
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * - The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ * - The Software is provided "as is", without warranty of any kind, express or
+ *   implied, including but not limited to the warranties of merchantability,
+ *   fitness for a particular purpose and noninfringement. In no event shall the
+ *   authors or copyright holders be liable for any claim, damages or other
+ *   liability, whether in an action of contract, tort or otherwise, arising from,
+ *   out of or in connection with the Software or the use or other dealings in the
+ *   Software.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * This library creates QR Code symbols, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * A QR Code structure is an immutable square grid of black and white cells.
+ * The library provides functions to create a QR Code from text or binary data.
+ * The library covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ *
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
+ * - Low level: Custom-make the list of segments and call
+ *   qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
+ * (Note that all ways require supplying the desired error correction level and various byte buffers.)
+ */
+
+
+/*---- Enum and struct types----*/
+
+/*
+ * The error correction level in a QR Code symbol.
+ */
+enum qrcodegen_Ecc {
+	// Must be declared in ascending order of error protection
+	// so that an internal qrcodegen function works properly
+	qrcodegen_Ecc_LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+	qrcodegen_Ecc_MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+	qrcodegen_Ecc_QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+	qrcodegen_Ecc_HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+};
+
+
+/*
+ * The mask pattern used in a QR Code symbol.
+ */
+enum qrcodegen_Mask {
+	// A special value to tell the QR Code encoder to
+	// automatically select an appropriate mask pattern
+	qrcodegen_Mask_AUTO = -1,
+	// The eight actual mask patterns
+	qrcodegen_Mask_0 = 0,
+	qrcodegen_Mask_1,
+	qrcodegen_Mask_2,
+	qrcodegen_Mask_3,
+	qrcodegen_Mask_4,
+	qrcodegen_Mask_5,
+	qrcodegen_Mask_6,
+	qrcodegen_Mask_7,
+};
+
+
+/*
+ * Describes how a segment's data bits are interpreted.
+ */
+enum qrcodegen_Mode {
+	qrcodegen_Mode_NUMERIC      = 0x1,
+	qrcodegen_Mode_ALPHANUMERIC = 0x2,
+	qrcodegen_Mode_BYTE         = 0x4,
+	qrcodegen_Mode_KANJI        = 0x8,
+	qrcodegen_Mode_ECI          = 0x7,
+};
+
+
+/*
+ * A segment of character/binary/control data in a QR Code symbol.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a factory function such as qrcodegen_makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and initialize a qrcodegen_Segment struct with appropriate values.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * Moreover, the maximum allowed bit length is 32767 because
+ * the largest QR Code (version 40) has 31329 modules.
+ */
+struct qrcodegen_Segment {
+	// The mode indicator of this segment.
+	enum qrcodegen_Mode mode;
+	
+	// The length of this segment's unencoded data. Measured in characters for
+	// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	// Always zero or positive. Not the same as the data's bit length.
+	int numChars;
+	
+	// The data bits of this segment, packed in bitwise big endian.
+	// Can be null if the bit length is zero.
+	uint8_t *data;
+	
+	// The number of valid data bits used in the buffer. Requires
+	// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
+	// The character count (numChars) must agree with the mode and the bit buffer length.
+	int bitLength;
+};
+
+
+
+/*---- Macro constants and functions ----*/
+
+#define qrcodegen_VERSION_MIN   1  // The minimum version number supported in the QR Code Model 2 standard
+#define qrcodegen_VERSION_MAX  40  // The maximum version number supported in the QR Code Model 2 standard
+
+// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
+// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
+// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
+// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
+#define qrcodegen_BUFFER_LEN_FOR_VERSION(n)  ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
+
+// The worst-case number of bytes needed to store one QR Code, up to and including
+// version 40. This value equals 3918, which is just under 4 kilobytes.
+// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
+#define qrcodegen_BUFFER_LEN_MAX  qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
+
+
+
+/*---- Functions (high level) to generate QR Codes ----*/
+
+/*
+ * Encodes the given text string to a QR Code, returning true if encoding succeeded.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * - The input text must be encoded in UTF-8 and contain no NULs.
+ * - The variables ecl and mask must correspond to enum constant values.
+ * - Requires 1 <= minVersion <= maxVersion <= 40.
+ * - The arrays tempBuffer and qrcode must each have a length
+ *   of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
+ * - After the function returns, tempBuffer contains no useful data.
+ * - If successful, the resulting QR Code may use numeric,
+ *   alphanumeric, or byte mode to encode the text.
+ * - In the most optimistic case, a QR Code at version 40 with low ECC
+ *   can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
+ *   up to 4296 characters, or any digit string up to 7089 characters.
+ *   These numbers represent the hard upper limit of the QR Code standard.
+ * - Please consult the QR Code specification for information on
+ *   data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*
+ * Encodes the given binary data to a QR Code, returning true if encoding succeeded.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * - The input array range dataAndTemp[0 : dataLen] should normally be
+ *   valid UTF-8 text, but is not required by the QR Code standard.
+ * - The variables ecl and mask must correspond to enum constant values.
+ * - Requires 1 <= minVersion <= maxVersion <= 40.
+ * - The arrays dataAndTemp and qrcode must each have a length
+ *   of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
+ * - After the function returns, the contents of dataAndTemp may have changed,
+ *   and does not represent useful data anymore.
+ * - If successful, the resulting QR Code will use byte mode to encode the data.
+ * - In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
+ *   sequence up to length 2953. This is the hard upper limit of the QR Code standard.
+ * - Please consult the QR Code specification for information on
+ *   data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*---- Functions (low level) to generate QR Codes ----*/
+
+/*
+ * Renders a QR Code representing the given segments at the given error correction level.
+ * The smallest possible QR Code version is automatically chosen for the output. Returns true if
+ * QR Code creation succeeded, or false if the data is too long to fit in any version. The ECC level
+ * of the result may be higher than the ecl argument if it can be done without increasing the version.
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ * To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
+ * result in them being clobbered, but the QR Code output will still be correct.
+ * But the qrcode array must not overlap tempBuffer or any segment's data buffer.
+ */
+bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
+	enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/*
+ * Renders a QR Code representing the given segments with the given encoding parameters.
+ * Returns true if QR Code creation succeeded, or false if the data is too long to fit in the range of versions.
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask number is either between 0 to 7 (inclusive) to force that
+ * mask, or -1 to automatically choose an appropriate mask (which may be slow).
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ * To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
+ * result in them being clobbered, but the QR Code output will still be correct.
+ * But the qrcode array must not overlap tempBuffer or any segment's data buffer.
+ */
+bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
+	int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/*
+ * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+ * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+ * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+bool qrcodegen_isAlphanumeric(const char *text);
+
+
+/*
+ * Tests whether the given string can be encoded as a segment in numeric mode.
+ * A string is encodable iff each character is in the range 0 to 9.
+ */
+bool qrcodegen_isNumeric(const char *text);
+
+
+/*
+ * Returns the number of bytes (uint8_t) needed for the data buffer of a segment
+ * containing the given number of characters using the given mode. Notes:
+ * - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or
+ *   the number of needed bits exceeds INT16_MAX (i.e. 32767).
+ * - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
+ * - It is okay for the user to allocate more bytes for the buffer than needed.
+ * - For byte mode, numChars measures the number of bytes, not Unicode code points.
+ * - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
+ *   An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
+ */
+size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
+
+
+/*
+ * Returns a segment representing the given binary data encoded in
+ * byte mode. All input byte arrays are acceptable. Any text string
+ * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+ */
+struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
+
+
+/*
+ * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+ */
+struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
+
+
+/*
+ * Returns a segment representing the given text string encoded in alphanumeric mode.
+ * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+ * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
+
+
+/*
+ * Returns a segment representing an Extended Channel Interpretation
+ * (ECI) designator with the given assignment value.
+ */
+struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
+
+
+/*---- Functions to extract raw data from QR Codes ----*/
+
+/*
+ * Returns the side length of the given QR Code, assuming that encoding succeeded.
+ * The result is in the range [21, 177]. Note that the length of the array buffer
+ * is related to the side length - every 'uint8_t qrcode[]' must have length at least
+ * qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
+ */
+int qrcodegen_getSize(const uint8_t qrcode[]);
+
+
+/*
+ * Returns the color of the module (pixel) at the given coordinates, which is false
+ * for white or true for black. The top left corner has the coordinates (x=0, y=0).
+ * If the given coordinates are out of bounds, then false (white) is returned.
+ */
+bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
+
+/*
+ * Returns the qrcode size of the specified version. Returns -1 on failure
+ */
+int qrcodegen_version2size(int version);
+/*
+ * Returns the min version of the data that can be stored. Returns -1 on failure
+ */
+int qrcodegen_getMinFitVersion(enum qrcodegen_Ecc ecl, size_t dataLen);
+
+#ifdef __cplusplus
+}
+#endif

include/liblvgl/extra/libs/rlottie/lv_rlottie.h

@@ -0,0 +1,75 @@
+/**
+ * @file lv_rlottie.h
+ *
+ */
+
+#ifndef LV_RLOTTIE_H
+#define LV_RLOTTIE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+#if LV_USE_RLOTTIE
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef enum {
+    LV_RLOTTIE_CTRL_FORWARD  = 0,
+    LV_RLOTTIE_CTRL_BACKWARD = 1,
+    LV_RLOTTIE_CTRL_PAUSE    = 2,
+    LV_RLOTTIE_CTRL_PLAY     = 0, /* Yes, play = 0 is the default mode */
+    LV_RLOTTIE_CTRL_LOOP     = 8,
+} lv_rlottie_ctrl_t;
+
+/** definition in lottieanimation_capi.c */
+struct Lottie_Animation_S;
+typedef struct {
+    lv_img_t img_ext;
+    struct Lottie_Animation_S * animation;
+    lv_timer_t * task;
+    lv_img_dsc_t imgdsc;
+    size_t total_frames;
+    size_t current_frame;
+    size_t framerate;
+    uint32_t * allocated_buf;
+    size_t allocated_buffer_size;
+    size_t scanline_width;
+    lv_rlottie_ctrl_t play_ctrl;
+    size_t dest_frame;
+} lv_rlottie_t;
+
+extern const lv_obj_class_t lv_rlottie_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_rlottie_create_from_file(lv_obj_t * parent, lv_coord_t width, lv_coord_t height, const char * path);
+
+lv_obj_t * lv_rlottie_create_from_raw(lv_obj_t * parent, lv_coord_t width, lv_coord_t height,
+                                      const char * rlottie_desc);
+
+void lv_rlottie_set_play_mode(lv_obj_t * rlottie, const lv_rlottie_ctrl_t ctrl);
+void lv_rlottie_set_current_frame(lv_obj_t * rlottie, const size_t goto_frame);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_RLOTTIE*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_RLOTTIE_H*/

include/liblvgl/extra/libs/sjpg/lv_sjpg.h

@@ -0,0 +1,43 @@
+/**
+ * @file lv_sjpg.h
+ *
+ */
+
+#ifndef LV_SJPEG_H
+#define LV_SJPEG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#if LV_USE_SJPG
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_split_jpeg_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_SJPG*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LV_SJPEG_H */

include/liblvgl/extra/libs/sjpg/tjpgd.h

@@ -0,0 +1,93 @@
+/*----------------------------------------------------------------------------/
+/ TJpgDec - Tiny JPEG Decompressor R0.03 include file         (C)ChaN, 2021
+/----------------------------------------------------------------------------*/
+#ifndef DEF_TJPGDEC
+#define DEF_TJPGDEC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "liblvgl/lv_conf_internal.h"
+#if LV_USE_SJPG
+
+#include "tjpgdcnf.h"
+#include <string.h>
+#include <stdint.h>
+
+#if JD_FASTDECODE >= 1
+typedef int16_t jd_yuv_t;
+#else
+typedef uint8_t jd_yuv_t;
+#endif
+
+
+/* Error code */
+typedef enum {
+	JDR_OK = 0,	/* 0: Succeeded */
+	JDR_INTR,	/* 1: Interrupted by output function */	
+	JDR_INP,	/* 2: Device error or wrong termination of input stream */
+	JDR_MEM1,	/* 3: Insufficient memory pool for the image */
+	JDR_MEM2,	/* 4: Insufficient stream input buffer */
+	JDR_PAR,	/* 5: Parameter error */
+	JDR_FMT1,	/* 6: Data format error (may be broken data) */
+	JDR_FMT2,	/* 7: Right format but not supported */
+	JDR_FMT3	/* 8: Not supported JPEG standard */
+} JRESULT;
+
+/* Rectangular region in the output image */
+typedef struct {
+	uint16_t left;		/* Left end */
+	uint16_t right;		/* Right end */
+	uint16_t top;		/* Top end */
+	uint16_t bottom;	/* Bottom end */
+} JRECT;
+
+/* Decompressor object structure */
+typedef struct JDEC JDEC;
+struct JDEC {
+	size_t dctr;				/* Number of bytes available in the input buffer */
+	uint8_t* dptr;				/* Current data read ptr */
+	uint8_t* inbuf;				/* Bit stream input buffer */
+	uint8_t dbit;				/* Number of bits availavble in wreg or reading bit mask */
+	uint8_t scale;				/* Output scaling ratio */
+	uint8_t msx, msy;			/* MCU size in unit of block (width, height) */
+	uint8_t qtid[3];			/* Quantization table ID of each component, Y, Cb, Cr */
+	uint8_t ncomp;				/* Number of color components 1:grayscale, 3:color */
+	int16_t dcv[3];				/* Previous DC element of each component */
+	uint16_t nrst;				/* Restart inverval */
+	uint16_t width, height;		/* Size of the input image (pixel) */
+	uint8_t* huffbits[2][2];	/* Huffman bit distribution tables [id][dcac] */
+	uint16_t* huffcode[2][2];	/* Huffman code word tables [id][dcac] */
+	uint8_t* huffdata[2][2];	/* Huffman decoded data tables [id][dcac] */
+	int32_t* qttbl[4];			/* Dequantizer tables [id] */
+#if JD_FASTDECODE >= 1
+	uint32_t wreg;				/* Working shift register */
+	uint8_t marker;				/* Detected marker (0:None) */
+#if JD_FASTDECODE == 2
+	uint8_t longofs[2][2];		/* Table offset of long code [id][dcac] */
+	uint16_t* hufflut_ac[2];	/* Fast huffman decode tables for AC short code [id] */
+	uint8_t* hufflut_dc[2];		/* Fast huffman decode tables for DC short code [id] */
+#endif
+#endif
+	void* workbuf;				/* Working buffer for IDCT and RGB output */
+	jd_yuv_t* mcubuf;			/* Working buffer for the MCU */
+	void* pool;					/* Pointer to available memory pool */
+	size_t sz_pool;				/* Size of momory pool (bytes available) */
+	size_t (*infunc)(JDEC*, uint8_t*, size_t);	/* Pointer to jpeg stream input function */
+	void* device;				/* Pointer to I/O device identifiler for the session */
+};
+
+
+
+/* TJpgDec API functions */
+JRESULT jd_prepare (JDEC* jd, size_t (*infunc)(JDEC*,uint8_t*,size_t), void* pool, size_t sz_pool, void* dev);
+JRESULT jd_decomp (JDEC* jd, int (*outfunc)(JDEC*,void*,JRECT*), uint8_t scale);
+
+#endif /*LV_USE_SJPG*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TJPGDEC */

include/liblvgl/extra/libs/sjpg/tjpgdcnf.h

@@ -0,0 +1,33 @@
+/*----------------------------------------------*/
+/* TJpgDec System Configurations R0.03          */
+/*----------------------------------------------*/
+
+#define	JD_SZBUF		512
+/* Specifies size of stream input buffer */
+
+#define JD_FORMAT		0
+/* Specifies output pixel format.
+/  0: RGB888 (24-bit/pix)
+/  1: RGB565 (16-bit/pix)
+/  2: Grayscale (8-bit/pix)
+*/
+
+#define	JD_USE_SCALE	1
+/* Switches output descaling feature.
+/  0: Disable
+/  1: Enable
+*/
+
+#define JD_TBLCLIP		1
+/* Use table conversion for saturation arithmetic. A bit faster, but increases 1 KB of code size.
+/  0: Disable
+/  1: Enable
+*/
+
+#define JD_FASTDECODE	0
+/* Optimization level
+/  0: Basic optimization. Suitable for 8/16-bit MCUs.
+/  1: + 32-bit barrel shifter. Suitable for 32-bit MCUs.
+/  2: + Table conversion for huffman decoding (wants 6 << HUFF_BIT bytes of RAM)
+*/
+

include/liblvgl/extra/lv_extra.h

@@ -0,0 +1,48 @@
+/**
+ * @file lv_extra.h
+ *
+ */
+
+#ifndef LV_EXTRA_H
+#define LV_EXTRA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "layouts/lv_layouts.h"
+#include "libs/lv_libs.h"
+#include "others/lv_others.h"
+#include "themes/lv_themes.h"
+#include "widgets/lv_widgets.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the extra components
+ */
+void lv_extra_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_EXTRA_H*/

include/liblvgl/extra/others/fragment/lv_fragment.h

@@ -0,0 +1,339 @@
+/**
+ * Public header for Fragment
+ * @file lv_fragment.h
+ */
+
+#ifndef LV_FRAGMENT_H
+#define LV_FRAGMENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_FRAGMENT
+
+#include "liblvgl/core/lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct _lv_fragment_manager_t lv_fragment_manager_t;
+
+typedef struct _lv_fragment_t lv_fragment_t;
+typedef struct _lv_fragment_class_t lv_fragment_class_t;
+typedef struct _lv_fragment_managed_states_t lv_fragment_managed_states_t;
+
+struct _lv_fragment_t {
+    /**
+     * Class of this fragment
+     */
+    const lv_fragment_class_t * cls;
+    /**
+     * Managed fragment states. If not null, then this fragment is managed.
+     *
+     * @warning Don't modify values inside this struct!
+     */
+    lv_fragment_managed_states_t * managed;
+    /**
+     * Child fragment manager
+     */
+    lv_fragment_manager_t * child_manager;
+    /**
+     * lv_obj returned by create_obj_cb
+     */
+    lv_obj_t * obj;
+
+};
+
+struct _lv_fragment_class_t {
+    /**
+     * Constructor function for fragment class
+     * @param self Fragment instance
+     * @param args Arguments assigned by fragment manager
+     */
+    void (*constructor_cb)(lv_fragment_t * self, void * args);
+
+    /**
+     * Destructor function for fragment class
+     * @param self Fragment instance, will be freed after this call
+     */
+    void (*destructor_cb)(lv_fragment_t * self);
+
+    /**
+     * Fragment attached to manager
+     * @param self Fragment instance
+     */
+    void (*attached_cb)(lv_fragment_t * self);
+
+    /**
+     * Fragment detached from manager
+     * @param self Fragment instance
+     */
+    void (*detached_cb)(lv_fragment_t * self);
+
+    /**
+     * Create objects
+     * @param self Fragment instance
+     * @param container Container of the objects should be created upon
+     * @return Created object, NULL if multiple objects has been created
+     */
+    lv_obj_t * (*create_obj_cb)(lv_fragment_t * self, lv_obj_t * container);
+
+    /**
+     *
+     * @param self Fragment instance
+     * @param obj lv_obj returned by create_obj_cb
+     */
+    void (*obj_created_cb)(lv_fragment_t * self, lv_obj_t * obj);
+
+    /**
+     * Called before objects in the fragment will be deleted.
+     *
+     * @param self Fragment instance
+     * @param obj object with this fragment
+     */
+    void (*obj_will_delete_cb)(lv_fragment_t * self, lv_obj_t * obj);
+
+    /**
+     * Called when the object created by fragment received `LV_EVENT_DELETE` event
+     * @param self Fragment instance
+     * @param obj object with this fragment
+     */
+    void (*obj_deleted_cb)(lv_fragment_t * self, lv_obj_t * obj);
+
+    /**
+     * Handle event
+     * @param self Fragment instance
+     * @param which User-defined ID of event
+     * @param data1 User-defined data
+     * @param data2 User-defined data
+     */
+    bool (*event_cb)(lv_fragment_t * self, int code, void * userdata);
+
+    /**
+     * *REQUIRED*: Allocation size of fragment
+     */
+    size_t instance_size;
+};
+
+/**
+ * Fragment states
+ */
+typedef struct _lv_fragment_managed_states_t  {
+    /**
+     * Class of the fragment
+     */
+    const lv_fragment_class_t * cls;
+    /**
+     * Manager the fragment attached to
+     */
+    lv_fragment_manager_t * manager;
+    /**
+     * Container object the fragment adding view to
+     */
+    lv_obj_t * const * container;
+    /**
+     * Fragment instance
+     */
+    lv_fragment_t * instance;
+    /**
+     * true between `create_obj_cb` and `obj_deleted_cb`
+     */
+    bool obj_created;
+    /**
+     * true before `lv_fragment_del_obj` is called. Don't touch any object if this is true
+     */
+    bool destroying_obj;
+    /**
+     * true if this fragment is in navigation stack that can be popped
+     */
+    bool in_stack;
+} lv_fragment_managed_states_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create fragment manager instance
+ * @param parent Parent fragment if this manager is placed inside another fragment, can be null.
+ * @return Fragment manager instance
+ */
+lv_fragment_manager_t * lv_fragment_manager_create(lv_fragment_t * parent);
+
+/**
+ * Destroy fragment manager instance
+ * @param manager Fragment manager instance
+ */
+void lv_fragment_manager_del(lv_fragment_manager_t * manager);
+
+/**
+ * Create object of all fragments managed by this manager.
+ * @param manager Fragment manager instance
+ */
+void lv_fragment_manager_create_obj(lv_fragment_manager_t * manager);
+
+/**
+ * Delete object created by all fragments managed by this manager. Instance of fragments will not be deleted.
+ * @param manager Fragment manager instance
+ */
+void lv_fragment_manager_del_obj(lv_fragment_manager_t * manager);
+
+/**
+ * Attach fragment to manager, and add to container.
+ * @param manager Fragment manager instance
+ * @param fragment Fragment instance
+ * @param container Pointer to container object for manager to add objects to
+ */
+void lv_fragment_manager_add(lv_fragment_manager_t * manager, lv_fragment_t * fragment, lv_obj_t * const * container);
+
+/**
+ * Detach and destroy fragment. If fragment is in navigation stack, remove from it.
+ * @param manager Fragment manager instance
+ * @param fragment Fragment instance
+ */
+void lv_fragment_manager_remove(lv_fragment_manager_t * manager, lv_fragment_t * fragment);
+
+/**
+ * Attach fragment to manager and add to navigation stack.
+ * @param manager Fragment manager instance
+ * @param fragment Fragment instance
+ * @param container Pointer to container object for manager to add objects to
+ */
+void lv_fragment_manager_push(lv_fragment_manager_t * manager, lv_fragment_t * fragment, lv_obj_t * const * container);
+
+/**
+ * Remove the top-most fragment for stack
+ * @param manager Fragment manager instance
+ * @return true if there is fragment to pop
+ */
+bool lv_fragment_manager_pop(lv_fragment_manager_t * manager);
+
+/**
+ * Replace fragment. Old item in the stack will be removed.
+ * @param manager Fragment manager instance
+ * @param fragment Fragment instance
+ * @param container Pointer to container object for manager to add objects to
+ */
+void lv_fragment_manager_replace(lv_fragment_manager_t * manager, lv_fragment_t * fragment,
+                                 lv_obj_t * const * container);
+
+/**
+ * Send event to top-most fragment
+ * @param manager Fragment manager instance
+ * @param code User-defined ID of event
+ * @param userdata User-defined data
+ * @return true if fragment returned true
+ */
+bool lv_fragment_manager_send_event(lv_fragment_manager_t * manager, int code, void * userdata);
+
+/**
+ * Get stack size of this fragment manager
+ * @param manager Fragment manager instance
+ * @return Stack size of this fragment manager
+ */
+size_t lv_fragment_manager_get_stack_size(lv_fragment_manager_t * manager);
+
+/**
+ * Get top most fragment instance
+ * @param manager Fragment manager instance
+ * @return Top most fragment instance
+ */
+lv_fragment_t * lv_fragment_manager_get_top(lv_fragment_manager_t * manager);
+
+/**
+ * Find first fragment instance in the container
+ * @param manager Fragment manager instance
+ * @param container Container which target fragment added to
+ * @return First fragment instance in the container
+ */
+lv_fragment_t * lv_fragment_manager_find_by_container(lv_fragment_manager_t * manager, const lv_obj_t * container);
+
+/**
+ * Get parent fragment
+ * @param manager Fragment manager instance
+ * @return Parent fragment instance
+ */
+lv_fragment_t * lv_fragment_manager_get_parent_fragment(lv_fragment_manager_t * manager);
+
+
+/**
+ * Create a fragment instance.
+ *
+ * @param cls Fragment class. This fragment must return non null object.
+ * @param args Arguments assigned by fragment manager
+ * @return Fragment instance
+ */
+lv_fragment_t * lv_fragment_create(const lv_fragment_class_t * cls, void * args);
+
+/**
+ * Destroy a fragment.
+ * @param fragment Fragment instance.
+ */
+void lv_fragment_del(lv_fragment_t * fragment);
+
+/**
+ * Get associated manager of this fragment
+ * @param fragment Fragment instance
+ * @return Fragment manager instance
+ */
+lv_fragment_manager_t * lv_fragment_get_manager(lv_fragment_t * fragment);
+
+/**
+ * Get container object of this fragment
+ * @param fragment Fragment instance
+ * @return Reference to container object
+ */
+lv_obj_t * const * lv_fragment_get_container(lv_fragment_t * fragment);
+
+/**
+ * Get parent fragment of this fragment
+ * @param fragment Fragment instance
+ * @return Parent fragment
+ */
+lv_fragment_t * lv_fragment_get_parent(lv_fragment_t * fragment);
+
+/**
+ * Create object by fragment.
+ *
+ * @param fragment Fragment instance.
+ * @param container Container of the objects should be created upon.
+ * @return Created object
+ */
+lv_obj_t * lv_fragment_create_obj(lv_fragment_t * fragment, lv_obj_t * container);
+
+/**
+ * Delete created object of a fragment
+ *
+ * @param fragment Fragment instance.
+ */
+void lv_fragment_del_obj(lv_fragment_t * fragment);
+
+/**
+ * Destroy obj in fragment, and recreate them.
+ * @param fragment Fragment instance
+ */
+void lv_fragment_recreate_obj(lv_fragment_t * fragment);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_FRAGMENT*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_FRAGMENT_H*/

include/liblvgl/extra/others/gridnav/lv_gridnav.h

@@ -0,0 +1,123 @@
+/**
+ * @file lv_templ.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*This typedef exists purely to keep -Wpedantic happy when the file is empty.*/
+/*It can be removed.*/
+typedef int _keep_pedantic_happy;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+/**
+ * @file lv_gridnav.h
+ *
+ */
+
+#ifndef LV_GRIDFOCUS_H
+#define LV_GRIDFOCUS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_GRIDNAV
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef enum {
+    LV_GRIDNAV_CTRL_NONE = 0x0,
+
+    /**
+     * If there is no next/previous object in a direction,
+     * the focus goes to the object in the next/previous row (on left/right keys)
+     * or first/last row (on up/down keys)
+     */
+    LV_GRIDNAV_CTRL_ROLLOVER = 0x1,
+
+    /**
+     * If an arrow is pressed and the focused object can be scrolled in that direction
+     * then it will be scrolled instead of going to the next/previous object.
+     * If there is no more room for scrolling the next/previous object will be focused normally */
+    LV_GRIDNAV_CTRL_SCROLL_FIRST = 0x2,
+
+} lv_gridnav_ctrl_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Add grid navigation feature to an object. It expects the children to be arranged
+ * into a grid-like layout. Although it's not required to have pixel perfect alignment.
+ * This feature makes possible to use keys to navigate among the children and focus them.
+ * The keys other than arrows and press/release related events
+ * are forwarded to the focused child.
+ * @param obj       pointer to an object on which navigation should be applied.
+ * @param ctrl      control flags from `lv_gridnav_ctrl_t`.
+ */
+void lv_gridnav_add(lv_obj_t * obj, lv_gridnav_ctrl_t ctrl);
+
+/**
+ * Remove the grid navigation support from an object
+ * @param obj       pointer to an object
+ */
+void lv_gridnav_remove(lv_obj_t * obj);
+
+/**
+ * Manually focus an object on gridnav container
+ * @param cont      pointer to a gridnav container
+ * @param to_focus  pointer to an object to focus
+ * @param anim_en   LV_ANIM_ON/OFF
+ */
+void lv_gridnav_set_focused(lv_obj_t * cont, lv_obj_t * to_focus, lv_anim_enable_t anim_en);
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_GRIDNAV*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GRIDFOCUS_H*/

include/liblvgl/extra/others/ime/lv_ime_pinyin.h

@@ -0,0 +1,145 @@
+/**
+ * @file lv_ime_pinyin.h
+ *
+ */
+#ifndef LV_IME_PINYIN_H
+#define LV_IME_PINYIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_IME_PINYIN != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_IME_PINYIN_K9_MAX_INPUT  7
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_IME_PINYIN_MODE_K26,
+    LV_IME_PINYIN_MODE_K9,
+} lv_ime_pinyin_mode_t;
+
+/*Data of pinyin_dict*/
+typedef struct {
+    const char * const py;
+    const char * const py_mb;
+} lv_pinyin_dict_t;
+
+/*Data of 9-key input(k9) mode*/
+typedef struct {
+    char py_str[7];
+} ime_pinyin_k9_py_str_t;
+
+/*Data of lv_ime_pinyin*/
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * kb;
+    lv_obj_t * cand_panel;
+    lv_pinyin_dict_t * dict;
+    lv_ll_t k9_legal_py_ll;
+    char * cand_str;            /* Candidate string */
+    char   input_char[16];      /* Input box character */
+#if LV_IME_PINYIN_USE_K9_MODE
+    char   k9_input_str[LV_IME_PINYIN_K9_MAX_INPUT]; /* 9-key input(k9) mode input string */
+    uint16_t k9_py_ll_pos;      /* Current pinyin map pages(k9) */
+    uint16_t k9_legal_py_count; /* Count of legal Pinyin numbers(k9) */
+    uint16_t k9_input_str_len;  /* 9-key input(k9) mode input string max len */
+#endif
+    uint16_t ta_count;          /* The number of characters entered in the text box this time */
+    uint16_t cand_num;          /* Number of candidates */
+    uint16_t py_page;           /* Current pinyin map pages(k26) */
+    uint16_t py_num[26];        /* Number and length of Pinyin */
+    uint16_t py_pos[26];        /* Pinyin position */
+    uint8_t  mode : 1;          /* Set mode, 1: 26-key input(k26), 0: 9-key input(k9). Default: 1. */
+} lv_ime_pinyin_t;
+
+/***********************
+ * GLOBAL VARIABLES
+ ***********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+lv_obj_t * lv_ime_pinyin_create(lv_obj_t * parent);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set the keyboard of Pinyin input method.
+ * @param obj  pointer to a Pinyin input method object
+ * @param dict pointer to a Pinyin input method keyboard
+ */
+void lv_ime_pinyin_set_keyboard(lv_obj_t * obj, lv_obj_t * kb);
+
+/**
+ * Set the dictionary of Pinyin input method.
+ * @param obj  pointer to a Pinyin input method object
+ * @param dict pointer to a Pinyin input method dictionary
+ */
+void lv_ime_pinyin_set_dict(lv_obj_t * obj, lv_pinyin_dict_t * dict);
+
+/**
+ * Set mode, 26-key input(k26) or 9-key input(k9).
+ * @param obj  pointer to a Pinyin input method object
+ * @param mode   the mode from 'lv_ime_pinyin_mode_t'
+ */
+void lv_ime_pinyin_set_mode(lv_obj_t * obj, lv_ime_pinyin_mode_t mode);
+
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Set the dictionary of Pinyin input method.
+ * @param obj  pointer to a Pinyin IME object
+ * @return     pointer to the Pinyin IME keyboard
+ */
+lv_obj_t * lv_ime_pinyin_get_kb(lv_obj_t * obj);
+
+
+/**
+ * Set the dictionary of Pinyin input method.
+ * @param obj  pointer to a Pinyin input method object
+ * @return     pointer to the Pinyin input method candidate panel
+ */
+lv_obj_t * lv_ime_pinyin_get_cand_panel(lv_obj_t * obj);
+
+
+/**
+ * Set the dictionary of Pinyin input method.
+ * @param obj  pointer to a Pinyin input method object
+ * @return     pointer to the Pinyin input method dictionary
+ */
+lv_pinyin_dict_t * lv_ime_pinyin_get_dict(lv_obj_t * obj);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_IME_PINYIN*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_USE_IME_PINYIN*/
+
+

include/liblvgl/extra/others/imgfont/lv_imgfont.h

@@ -0,0 +1,60 @@
+/**
+ * @file lv_imgfont.h
+ *
+ */
+
+#ifndef LV_IMGFONT_H
+#define LV_IMGFONT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_IMGFONT
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/* gets the image path name of this character */
+typedef bool (*lv_get_imgfont_path_cb_t)(const lv_font_t * font, void * img_src,
+                                         uint16_t len, uint32_t unicode, uint32_t unicode_next);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Creates a image font with info parameter specified.
+ * @param height font size
+ * @param path_cb a function to get the image path name of character.
+ * @return pointer to the new imgfont or NULL if create error.
+ */
+lv_font_t * lv_imgfont_create(uint16_t height, lv_get_imgfont_path_cb_t path_cb);
+
+/**
+ * Destroy a image font that has been created.
+ * @param font pointer to image font handle.
+ */
+void lv_imgfont_destroy(lv_font_t * font);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_IMGFONT*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* LV_IMGFONT_H */

include/liblvgl/extra/others/lv_others.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_others.h
+ *
+ */
+
+#ifndef LV_OTHERS_H
+#define LV_OTHERS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "snapshot/lv_snapshot.h"
+#include "monkey/lv_monkey.h"
+#include "gridnav/lv_gridnav.h"
+#include "fragment/lv_fragment.h"
+#include "imgfont/lv_imgfont.h"
+#include "msg/lv_msg.h"
+#include "ime/lv_ime_pinyin.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OTHERS_H*/

include/liblvgl/extra/others/monkey/lv_monkey.h

@@ -0,0 +1,118 @@
+/**
+ * @file lv_monkey.h
+ *
+ */
+#ifndef LV_MONKEY_H
+#define LV_MONKEY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_MONKEY != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+struct _lv_monkey;
+typedef struct _lv_monkey lv_monkey_t;
+
+typedef struct {
+    /**< Input device type*/
+    lv_indev_type_t type;
+
+    /**< Monkey execution period*/
+    struct {
+        uint32_t min;
+        uint32_t max;
+    } period_range;
+
+    /**< The range of input value*/
+    struct {
+        int32_t min;
+        int32_t max;
+    } input_range;
+} lv_monkey_config_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a monkey config with default values
+ * @param config pointer to 'lv_monkey_config_t' variable to initialize
+ */
+void lv_monkey_config_init(lv_monkey_config_t * config);
+
+/**
+ * Create monkey for test
+ * @param config pointer to 'lv_monkey_config_t' variable
+ * @return pointer to the created monkey
+ */
+lv_monkey_t * lv_monkey_create(const lv_monkey_config_t * config);
+
+/**
+ * Get monkey input device
+ * @param monkey pointer to a monkey
+ * @return pointer to the input device
+ */
+lv_indev_t * lv_monkey_get_indev(lv_monkey_t * monkey);
+
+/**
+ * Enable monkey
+ * @param monkey pointer to a monkey
+ * @param en set to true to enable
+ */
+void lv_monkey_set_enable(lv_monkey_t * monkey, bool en);
+
+/**
+ * Get whether monkey is enabled
+ * @param monkey pointer to a monkey
+ * @return return true if monkey enabled
+ */
+bool lv_monkey_get_enable(lv_monkey_t * monkey);
+
+#if LV_USE_USER_DATA
+
+/**
+ * Set the user_data field of the monkey
+ * @param monkey   pointer to a monkey
+ * @param user_data   pointer to the new user_data.
+ */
+void lv_monkey_set_user_data(lv_monkey_t * monkey, void * user_data);
+
+/**
+ * Get the user_data field of the monkey
+ * @param monkey pointer to a monkey
+ * @return the pointer to the user_data of the monkey
+ */
+void * lv_monkey_get_user_data(lv_monkey_t * monkey);
+
+#endif/*LV_USE_USER_DATA*/
+
+/**
+ * Delete monkey
+ * @param monkey pointer to monkey
+ */
+void lv_monkey_del(lv_monkey_t * monkey);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_MONKEY*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_MONKEY_H*/

include/liblvgl/extra/others/msg/lv_msg.h

@@ -0,0 +1,124 @@
+/**
+ * @file lv_msg.h
+ *
+ */
+
+#ifndef LV_MSG_H
+#define LV_MSG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#if LV_USE_MSG
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    uint32_t id;            /*Identifier of the message*/
+    void * user_data;       /*Set the the user_data set in `lv_msg_subscribe`*/
+    void * _priv_data;      /*Used internally*/
+    const void * payload;   /*Pointer to the data of the message*/
+} lv_msg_t;
+
+typedef void (*lv_msg_subscribe_cb_t)(void * s, lv_msg_t * msg);
+
+typedef void (*lv_msg_request_cb_t)(void * r, uint32_t msg_id);
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Called internally to initialize the message module
+ */
+void lv_msg_init(void);
+
+/**
+ * Subscribe to an `msg_id`
+ * @param msg_id        the message ID to listen to
+ * @param cb            callback to call if a message with `msg_id` was sent
+ * @param user_data     arbitrary data which will be available in `cb` too
+ * @return              pointer to a "subscribe object". It can be used the unsubscribe.
+ */
+void * lv_msg_subsribe(uint32_t msg_id, lv_msg_subscribe_cb_t cb, void * user_data);
+
+/**
+ * Subscribe an `lv_obj` to a message.
+ * `LV_EVENT_MSG_RECEIVED` will be triggered if a message with matching ID was sent
+ * @param msg_id        the message ID to listen to
+ * @param obj           pointer to an `lv_obj`
+ * @param user_data     arbitrary data which will be available in `cb` too
+ * @return              pointer to a "subscribe object". It can be used the unsubscribe.
+ */
+void * lv_msg_subsribe_obj(uint32_t msg_id, lv_obj_t * obj, void * user_data);
+
+/**
+ * Cancel a previous subscription
+ * @param s             pointer to a "subscibe object".
+ *                      Return value of `lv_msg_subsribe` or `lv_msg_subsribe_obj`
+ */
+void lv_msg_unsubscribe(void * s);
+
+/**
+ * Send a message with a given ID and payload
+ * @param msg_id        ID of the message to send
+ * @param data          pointer to the data to send
+ */
+void lv_msg_send(uint32_t msg_id, const void * payload);
+
+/**
+ * Get the ID of a message object. Typically used in the subscriber callback.
+ * @param m             pointer to a message object
+ * @return              the ID of the message
+ */
+uint32_t lv_msg_get_id(lv_msg_t * m);
+
+/**
+ * Get the payload of a message object. Typically used in the subscriber callback.
+ * @param m             pointer to a message object
+ * @return              the payload of the message
+ */
+const void * lv_msg_get_payload(lv_msg_t * m);
+
+/**
+ * Get the user data of a message object. Typically used in the subscriber callback.
+ * @param m             pointer to a message object
+ * @return              the user data of the message
+ */
+void * lv_msg_get_user_data(lv_msg_t * m);
+
+/**
+ * Get the message object from an event object. Can be used in `LV_EVENT_MSG_RECEIVED` events.
+ * @param e     pointer to an event object
+ * @return      the message object or NULL if called with unrelated event code.
+ */
+lv_msg_t * lv_event_get_msg(lv_event_t * e);
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+
+extern lv_event_code_t LV_EVENT_MSG_RECEIVED;
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_MSG*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_MSG_H*/

include/liblvgl/extra/others/snapshot/lv_snapshot.h

@@ -0,0 +1,84 @@
+/**
+ * @file lv_snapshot.h
+ *
+ */
+
+#ifndef LV_SNAPSHOT_H
+#define LV_SNAPSHOT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdint.h>
+#include <stddef.h>
+
+#include "liblvgl/lv_conf_internal.h"
+#include "liblvgl/core/lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#if LV_USE_SNAPSHOT
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/** Take snapshot for object with its children.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return a pointer to an image descriptor, or NULL if failed.
+ */
+lv_img_dsc_t * lv_snapshot_take(lv_obj_t * obj, lv_img_cf_t cf);
+
+/** Free the snapshot image returned by @ref lv_snapshot_take
+ *
+ * It will firstly free the data image takes, then the image descriptor.
+ *
+ * @param dsc    The image descriptor generated by lv_snapshot_take.
+ *
+ */
+void lv_snapshot_free(lv_img_dsc_t * dsc);
+
+/** Get the buffer needed for object snapshot image.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return the buffer size needed in bytes
+ */
+uint32_t lv_snapshot_buf_size_needed(lv_obj_t * obj, lv_img_cf_t cf);
+
+/** Take snapshot for object with its children, save image info to provided buffer.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ * @param dsc    image descriptor to store the image result.
+ * @param buff   the buffer to store image data.
+ * @param buff_size provided buffer size in bytes.
+ *
+ * @return LV_RES_OK on success, LV_RES_INV on error.
+ */
+lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * dsc, void * buf, uint32_t buff_size);
+
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_SNAPSHOT*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif

include/liblvgl/extra/themes/basic/lv_theme_basic.h

@@ -0,0 +1,55 @@
+/**
+ * @file lv_theme_basic.h
+ *
+ */
+
+#ifndef LV_THEME_BASIC_H
+#define LV_THEME_BASIC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_THEME_BASIC
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the theme
+ * @param disp pointer to display to attach the theme
+ * @return a pointer to reference this theme later
+ */
+lv_theme_t * lv_theme_basic_init(lv_disp_t * disp);
+
+/**
+* Check if the theme is initialized
+* @return true if default theme is initialized, false otherwise
+*/
+bool lv_theme_basic_is_inited(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_THEME_BASIC_H*/

include/liblvgl/extra/themes/default/lv_theme_default.h

@@ -0,0 +1,64 @@
+/**
+ * @file lv_theme_default.h
+ *
+ */
+
+#ifndef LV_THEME_DEFAULT_H
+#define LV_THEME_DEFAULT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_THEME_DEFAULT
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the theme
+ * @param color_primary the primary color of the theme
+ * @param color_secondary the secondary color for the theme
+ * @param font pointer to a font to use.
+ * @return a pointer to reference this theme later
+ */
+lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark,
+                                   const lv_font_t * font);
+
+/**
+ * Get default theme
+ * @return a pointer to default theme, or NULL if this is not initialized
+ */
+lv_theme_t * lv_theme_default_get(void);
+
+/**
+ * Check if default theme is initialized
+ * @return true if default theme is initialized, false otherwise
+ */
+bool lv_theme_default_is_inited(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_THEME_DEFAULT_H*/

include/liblvgl/extra/themes/lv_themes.h

@@ -0,0 +1,40 @@
+/**
+ * @file lv_themes.h
+ *
+ */
+
+#ifndef LV_THEMES_H
+#define LV_THEMES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "default/lv_theme_default.h"
+#include "mono/lv_theme_mono.h"
+#include "basic/lv_theme_basic.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_THEMES_H*/

include/liblvgl/extra/themes/mono/lv_theme_mono.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_theme_mono.h
+ *
+ */
+
+#ifndef LV_USE_THEME_MONO_H
+#define LV_USE_THEME_MONO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_THEME_MONO
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the theme
+ * @param color_primary the primary color of the theme
+ * @param color_secondary the secondary color for the theme
+ * @param font pointer to a font to use.
+ * @return a pointer to reference this theme later
+ */
+lv_theme_t * lv_theme_mono_init(lv_disp_t * disp, bool dark_bg, const lv_font_t * font);
+
+/**
+* Check if the theme is initialized
+* @return true if default theme is initialized, false otherwise
+*/
+bool lv_theme_mono_is_inited(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_USE_THEME_MONO_H*/

include/liblvgl/extra/widgets/animimg/lv_animimg.h

@@ -0,0 +1,103 @@
+/**
+ * @file lv_animimg.h
+ *
+ */
+
+#ifndef LV_ANIM_IMG_H
+#define LV_ANIM_IMG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_ANIMIMG != 0
+
+/*Testing of dependencies*/
+#if LV_USE_IMG == 0
+#error "lv_animimg: lv_img is required. Enable it in lv_conf.h (LV_USE_IMG 1)"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+extern const lv_obj_class_t lv_animimg_class;
+
+/*Data of image*/
+typedef struct {
+    lv_img_t img;
+    lv_anim_t anim;
+    /*picture sequence */
+    lv_img_dsc_t ** dsc;
+    int8_t  pic_count;
+} lv_animimg_t;
+
+
+/*Image parts*/
+enum {
+    LV_ANIM_IMG_PART_MAIN,
+};
+typedef uint8_t lv_animimg_part_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create an animation image objects
+ * @param parent pointer to an object, it will be the parent of the new button
+ * @return pointer to the created animation image object
+ */
+lv_obj_t * lv_animimg_create(lv_obj_t * parent);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set the image animation images source.
+ * @param img pointer to an animation image object
+ * @param dsc pointer to a series images
+ * @param num images' number
+ */
+void lv_animimg_set_src(lv_obj_t * img,  lv_img_dsc_t * dsc[], uint8_t num);
+
+/**
+ * Startup the image animation.
+ * @param obj pointer to an animation image object
+ */
+void lv_animimg_start(lv_obj_t * obj);
+
+/**
+ * Set the image animation duration time. unit:ms
+ * @param img pointer to an animation image object
+ */
+void lv_animimg_set_duration(lv_obj_t * img, uint32_t duration);
+
+/**
+ * Set the image animation reapeatly play times.
+ * @param img pointer to an animation image object
+ * @param count the number of times to repeat the animation
+ */
+void lv_animimg_set_repeat_count(lv_obj_t * img, uint16_t count);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+#endif /*LV_USE_ANIMIMG*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_ANIM_IMG_H*/

include/liblvgl/extra/widgets/calendar/lv_calendar.h

@@ -0,0 +1,164 @@
+/**
+ * @file lv_calendar.h
+ *
+ */
+
+#ifndef LV_CALENDAR_H
+#define LV_CALENDAR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/widgets/lv_btnmatrix.h"
+
+#if LV_USE_CALENDAR
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Represents a date on the calendar object (platform-agnostic).
+ */
+typedef struct {
+    uint16_t year;
+    int8_t month;  /** 1..12*/
+    int8_t day;    /** 1..31*/
+} lv_calendar_date_t;
+
+/*Data of calendar*/
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * btnm;
+    /*New data for this type*/
+    lv_calendar_date_t today;               /*Date of today*/
+    lv_calendar_date_t showed_date;         /*Currently visible month (day is ignored)*/
+    lv_calendar_date_t *
+    highlighted_dates; /*Apply different style on these days (pointer to an array defined by the user)*/
+    uint16_t highlighted_dates_num;          /*Number of elements in `highlighted_days`*/
+    const char * map[8 * 7];
+    char nums [7 * 6][4];
+} lv_calendar_t;
+
+extern const lv_obj_class_t lv_calendar_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_calendar_create(lv_obj_t * parent);
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set the today's date
+ * @param obj  pointer to a calendar object
+ * @param year      today's year
+ * @param month     today's month [1..12]
+ * @param day       today's day [1..31]
+ */
+void lv_calendar_set_today_date(lv_obj_t * obj, uint32_t year, uint32_t month, uint32_t day);
+
+/**
+ * Set the currently showed
+ * @param obj           pointer to a calendar object
+ * @param year          today's year
+ * @param month         today's month [1..12]
+ */
+void lv_calendar_set_showed_date(lv_obj_t * obj, uint32_t year, uint32_t month);
+
+/**
+ * Set the highlighted dates
+ * @param obj           pointer to a calendar object
+ * @param highlighted   pointer to an `lv_calendar_date_t` array containing the dates.
+ *                      Only the pointer will be saved so this variable can't be local which will be destroyed later.
+ * @param date_num number of dates in the array
+ */
+void lv_calendar_set_highlighted_dates(lv_obj_t * obj, lv_calendar_date_t highlighted[], uint16_t date_num);
+
+/**
+ * Set the name of the days
+ * @param obj           pointer to a calendar object
+ * @param day_names     pointer to an array with the names.
+ *                      E.g. `const char * days[7] = {"Sun", "Mon", ...}`
+ *                      Only the pointer will be saved so this variable can't be local which will be destroyed later.
+ */
+void lv_calendar_set_day_names(lv_obj_t * obj, const char ** day_names);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the button matrix object of the calendar.
+ * It shows the dates and day names.
+ * @param obj   pointer to a calendar object
+ * @return      pointer to a the button matrix
+ */
+lv_obj_t * lv_calendar_get_btnmatrix(const lv_obj_t * obj);
+
+/**
+ * Get the today's date
+ * @param calendar pointer to a calendar object
+ * @return return pointer to an `lv_calendar_date_t` variable containing the date of today.
+ */
+const lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar);
+
+/**
+ * Get the currently showed
+ * @param calendar pointer to a calendar object
+ * @return pointer to an `lv_calendar_date_t` variable containing the date is being shown.
+ */
+const lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar);
+
+/**
+ * Get the highlighted dates
+ * @param calendar pointer to a calendar object
+ * @return pointer to an `lv_calendar_date_t` array containing the dates.
+ */
+lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar);
+
+/**
+ * Get the number of the highlighted dates
+ * @param calendar pointer to a calendar object
+ * @return number of highlighted days
+ */
+uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar);
+
+/**
+ * Get the currently pressed day
+ * @param calendar pointer to a calendar object
+ * @param date store the pressed date here
+ * @return LV_RES_OK: there is a valid pressed date; LV_RES_INV: there is no pressed data
+ */
+lv_res_t lv_calendar_get_pressed_date(const lv_obj_t * calendar, lv_calendar_date_t * date);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_CALENDAR*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CALENDAR_H*/

include/liblvgl/extra/widgets/calendar/lv_calendar_header_arrow.h

@@ -0,0 +1,49 @@
+/**
+ * @file lv_calendar_header_arrow.h
+ *
+ */
+
+#ifndef LV_CALENDAR_HEADER_ARROW_H
+#define LV_CALENDAR_HEADER_ARROW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#if LV_USE_CALENDAR_HEADER_ARROW
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+extern const lv_obj_class_t lv_calendar_header_arrow_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a calendar header with drop-drowns to select the year and month
+ * @param parent    pointer to a calendar object.
+ * @return          the created header
+ */
+lv_obj_t * lv_calendar_header_arrow_create(lv_obj_t * parent);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_CALENDAR_HEADER_ARROW*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CALENDAR_HEADER_ARROW_H*/

include/liblvgl/extra/widgets/calendar/lv_calendar_header_dropdown.h

@@ -0,0 +1,49 @@
+/**
+ * @file lv_calendar_header_dropdown.h
+ *
+ */
+
+#ifndef LV_CALENDAR_HEADER_DROPDOWN_H
+#define LV_CALENDAR_HEADER_DROPDOWN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#if LV_USE_CALENDAR_HEADER_DROPDOWN
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+extern const lv_obj_class_t lv_calendar_header_dropdown_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a calendar header with drop-drowns to select the year and month
+ * @param parent    pointer to a calendar object.
+ * @return          the created header
+ */
+lv_obj_t * lv_calendar_header_dropdown_create(lv_obj_t * parent);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_CALENDAR_HEADER_ARROW*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CALENDAR_HEADER_DROPDOWN_H*/

include/liblvgl/extra/widgets/chart/lv_chart.h

@@ -0,0 +1,460 @@
+/**
+ * @file lv_chart.h
+ *
+ */
+
+#ifndef LV_CHART_H
+#define LV_CHART_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_CHART != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**Default value of points. Can be used to not draw a point*/
+#if LV_USE_LARGE_COORD
+#define LV_CHART_POINT_NONE (INT32_MAX)
+#else
+#define LV_CHART_POINT_NONE (INT16_MAX)
+#endif
+LV_EXPORT_CONST_INT(LV_CHART_POINT_NONE);
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Chart types
+ */
+enum {
+    LV_CHART_TYPE_NONE,     /**< Don't draw the series*/
+    LV_CHART_TYPE_LINE,     /**< Connect the points with lines*/
+    LV_CHART_TYPE_BAR,      /**< Draw columns*/
+    LV_CHART_TYPE_SCATTER,  /**< Draw points and lines in 2D (x,y coordinates)*/
+};
+typedef uint8_t lv_chart_type_t;
+
+/**
+ * Chart update mode for `lv_chart_set_next`
+ */
+enum {
+    LV_CHART_UPDATE_MODE_SHIFT,     /**< Shift old data to the left and add the new one the right*/
+    LV_CHART_UPDATE_MODE_CIRCULAR,  /**< Add the new data in a circular way*/
+};
+typedef uint8_t lv_chart_update_mode_t;
+
+/**
+ * Enumeration of the axis'
+ */
+enum {
+    LV_CHART_AXIS_PRIMARY_Y     = 0x00,
+    LV_CHART_AXIS_SECONDARY_Y   = 0x01,
+    LV_CHART_AXIS_PRIMARY_X     = 0x02,
+    LV_CHART_AXIS_SECONDARY_X   = 0x04,
+    _LV_CHART_AXIS_LAST
+};
+typedef uint8_t lv_chart_axis_t;
+
+/**
+ * Descriptor a chart series
+ */
+typedef struct {
+    lv_coord_t * x_points;
+    lv_coord_t * y_points;
+    lv_color_t color;
+    uint16_t start_point;
+    uint8_t hidden : 1;
+    uint8_t x_ext_buf_assigned : 1;
+    uint8_t y_ext_buf_assigned : 1;
+    uint8_t x_axis_sec : 1;
+    uint8_t y_axis_sec : 1;
+} lv_chart_series_t;
+
+typedef struct {
+    lv_point_t pos;
+    lv_coord_t point_id;
+    lv_color_t color;
+    lv_chart_series_t * ser;
+    lv_dir_t dir;
+    uint8_t pos_set: 1; /*1: pos is set; 0: point_id is set*/
+} lv_chart_cursor_t;
+
+typedef struct {
+    lv_coord_t major_len;
+    lv_coord_t minor_len;
+    lv_coord_t draw_size;
+    uint32_t minor_cnt : 15;
+    uint32_t major_cnt : 15;
+    uint32_t label_en  : 1;
+} lv_chart_tick_dsc_t;
+
+
+typedef struct {
+    lv_obj_t obj;
+    lv_ll_t series_ll;     /**< Linked list for the series (stores lv_chart_series_t)*/
+    lv_ll_t cursor_ll;     /**< Linked list for the cursors (stores lv_chart_cursor_t)*/
+    lv_chart_tick_dsc_t tick[4];
+    lv_coord_t ymin[2];
+    lv_coord_t ymax[2];
+    lv_coord_t xmin[2];
+    lv_coord_t xmax[2];
+    lv_coord_t pressed_point_id;
+    uint16_t hdiv_cnt;      /**< Number of horizontal division lines*/
+    uint16_t vdiv_cnt;      /**< Number of vertical division lines*/
+    uint16_t point_cnt;    /**< Point number in a data line*/
+    uint16_t zoom_x;
+    uint16_t zoom_y;
+    lv_chart_type_t type  : 3; /**< Line or column chart*/
+    lv_chart_update_mode_t update_mode : 1;
+} lv_chart_t;
+
+extern const lv_obj_class_t lv_chart_class;
+
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_chart_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_CHART_DRAW_PART_DIV_LINE_INIT,    /**< Used before/after drawn the div lines*/
+    LV_CHART_DRAW_PART_DIV_LINE_HOR,     /**< Used for each horizontal division lines*/
+    LV_CHART_DRAW_PART_DIV_LINE_VER,     /**< Used for each vertical division lines*/
+    LV_CHART_DRAW_PART_LINE_AND_POINT,   /**< Used on line and scatter charts for lines and points*/
+    LV_CHART_DRAW_PART_BAR,              /**< Used on bar charts for the rectangles*/
+    LV_CHART_DRAW_PART_CURSOR,           /**< Used on cursor lines and points*/
+    LV_CHART_DRAW_PART_TICK_LABEL,       /**< Used on tick lines and labels*/
+} lv_chart_draw_part_type_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a chart object
+ * @param parent    pointer to an object, it will be the parent of the new chart
+ * @return          pointer to the created chart
+ */
+lv_obj_t * lv_chart_create(lv_obj_t * parent);
+
+/**
+ * Set a new type for a chart
+ * @param obj       pointer to a chart object
+ * @param type      new type of the chart (from 'lv_chart_type_t' enum)
+ */
+void lv_chart_set_type(lv_obj_t * obj, lv_chart_type_t type);
+/**
+ * Set the number of points on a data line on a chart
+ * @param obj       pointer to a chart object
+ * @param cnt       new number of points on the data lines
+ */
+void lv_chart_set_point_count(lv_obj_t * obj, uint16_t cnt);
+
+/**
+ * Set the minimal and maximal y values on an axis
+ * @param obj       pointer to a chart object
+ * @param axis      `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
+ * @param min       minimum value of the y axis
+ * @param max       maximum value of the y axis
+ */
+void lv_chart_set_range(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t min, lv_coord_t max);
+
+/**
+ * Set update mode of the chart object. Affects
+ * @param obj       pointer to a chart object
+ * @param mode      the update mode
+ */
+void lv_chart_set_update_mode(lv_obj_t * obj, lv_chart_update_mode_t update_mode);
+
+/**
+ * Set the number of horizontal and vertical division lines
+ * @param obj       pointer to a chart object
+ * @param hdiv      number of horizontal division lines
+ * @param vdiv      number of vertical division lines
+ */
+void lv_chart_set_div_line_count(lv_obj_t * obj, uint8_t hdiv, uint8_t vdiv);
+
+/**
+ * Zoom into the chart in X direction
+ * @param obj       pointer to a chart object
+ * @param zoom_x    zoom in x direction. LV_ZOOM_NONE or 256 for no zoom, 512 double zoom
+ */
+void lv_chart_set_zoom_x(lv_obj_t * obj, uint16_t zoom_x);
+
+/**
+ * Zoom into the chart in Y direction
+ * @param obj       pointer to a chart object
+ * @param zoom_y    zoom in y direction. LV_ZOOM_NONE or 256 for no zoom, 512 double zoom
+ */
+void lv_chart_set_zoom_y(lv_obj_t * obj, uint16_t zoom_y);
+
+/**
+ * Get X zoom of a chart
+ * @param obj       pointer to a chart object
+ * @return          the X zoom value
+ */
+uint16_t lv_chart_get_zoom_x(const lv_obj_t * obj);
+
+/**
+ * Get Y zoom of a chart
+ * @param obj       pointer to a chart object
+ * @return          the Y zoom value
+ */
+uint16_t lv_chart_get_zoom_y(const lv_obj_t * obj);
+
+/**
+ * Set the number of tick lines on an axis
+ * @param obj           pointer to a chart object
+ * @param axis          an axis which ticks count should be set
+ * @param major_len     length of major ticks
+ * @param minor_len     length of minor ticks
+ * @param major_cnt     number of major ticks on the axis
+ * @param minor_cnt     number of minor ticks between two major ticks
+ * @param label_en      true: enable label drawing on major ticks
+ * @param draw_size     extra size required to draw the tick and labels
+ *                      (start with 20 px and increase if the ticks/labels are clipped)
+ */
+void lv_chart_set_axis_tick(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t major_len, lv_coord_t minor_len,
+                            lv_coord_t major_cnt, lv_coord_t minor_cnt, bool label_en, lv_coord_t draw_size);
+
+/**
+ * Get the type of a chart
+ * @param obj       pointer to chart object
+ * @return          type of the chart (from 'lv_chart_t' enum)
+ */
+lv_chart_type_t lv_chart_get_type(const lv_obj_t * obj);
+
+/**
+ * Get the data point number per data line on chart
+ * @param chart     pointer to chart object
+ * @return          point number on each data line
+ */
+uint16_t lv_chart_get_point_count(const lv_obj_t * obj);
+
+/**
+ * Get the current index of the x-axis start point in the data array
+ * @param chart     pointer to a chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @return          the index of the current x start point in the data array
+ */
+uint16_t lv_chart_get_x_start_point(const lv_obj_t * obj, lv_chart_series_t * ser);
+
+/**
+ * Get the position of a point to the chart.
+ * @param chart     pointer to a chart object
+ * @param ser       pointer to series
+ * @param id        the index.
+ * @param p_out     store the result position here
+ */
+void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_point_t * p_out);
+
+/**
+ * Refresh a chart if its data line has changed
+ * @param   chart pointer to chart object
+ */
+void lv_chart_refresh(lv_obj_t * obj);
+
+/*======================
+ * Series
+ *=====================*/
+
+/**
+ * Allocate and add a data series to the chart
+ * @param obj       pointer to a chart object
+ * @param color     color of the data series
+ * @param axis      the y axis to which the series should be attached (::LV_CHART_AXIS_PRIMARY_Y or ::LV_CHART_AXIS_SECONDARY_Y)
+ * @return          pointer to the allocated data series
+ */
+lv_chart_series_t * lv_chart_add_series(lv_obj_t * obj, lv_color_t color, lv_chart_axis_t axis);
+
+/**
+ * Deallocate and remove a data series from a chart
+ * @param chart     pointer to a chart object
+ * @param series    pointer to a data series on 'chart'
+ */
+void lv_chart_remove_series(lv_obj_t * obj, lv_chart_series_t * series);
+
+/**
+ * Hide/Unhide a single series of a chart.
+ * @param obj       pointer to a chart object.
+ * @param series    pointer to a series object
+ * @param hide      true: hide the series
+ */
+void lv_chart_hide_series(lv_obj_t * chart, lv_chart_series_t * series, bool hide);
+
+/**
+ * Change the color of a series
+ * @param obj       pointer to a chart object.
+ * @param series    pointer to a series object
+ * @param color     the new color of the series
+ */
+void lv_chart_set_series_color(lv_obj_t * chart, lv_chart_series_t * series, lv_color_t color);
+
+/**
+ * Set the index of the x-axis start point in the data array.
+ * This point will be considers the first (left) point and the other points will be drawn after it.
+ * @param obj       pointer to a chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param id        the index of the x point in the data array
+ */
+void lv_chart_set_x_start_point(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id);
+
+/**
+ * Get the next series.
+ * @param chart     pointer to a chart
+ * @param ser      the previous series or NULL to get the first
+ * @return          the next series or NULL if there is no more.
+ */
+lv_chart_series_t * lv_chart_get_series_next(const lv_obj_t * chart, const lv_chart_series_t * ser);
+
+
+
+/*=====================
+ * Cursor
+ *====================*/
+
+/**
+ * Add a cursor with a given color
+ * @param obj       pointer to chart object
+ * @param color     color of the cursor
+ * @param dir       direction of the cursor. `LV_DIR_RIGHT/LEFT/TOP/DOWN/HOR/VER/ALL`. OR-ed values are possible
+ * @return          pointer to the created cursor
+ */
+lv_chart_cursor_t  * lv_chart_add_cursor(lv_obj_t * obj, lv_color_t color, lv_dir_t dir);
+
+/**
+ * Set the coordinate of the cursor with respect to the paddings
+ * @param obj       pointer to a chart object
+ * @param cursor    pointer to the cursor
+ * @param pos       the new coordinate of cursor relative to the chart
+ */
+void lv_chart_set_cursor_pos(lv_obj_t * chart, lv_chart_cursor_t * cursor, lv_point_t * pos);
+
+/**
+ * Stick the cursor to a point
+ * @param obj       pointer to a chart object
+ * @param cursor    pointer to the cursor
+ * @param ser       pointer to a series
+ * @param point_id  the point's index or `LV_CHART_POINT_NONE` to not assign to any points.
+ */
+void lv_chart_set_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * cursor, lv_chart_series_t * ser,
+                               uint16_t point_id);
+
+/**
+ * Get the coordinate of the cursor with respect to the paddings
+ * @param obj       pointer to a chart object
+ * @param cursor    pointer to cursor
+ * @return          coordinate of the cursor as lv_point_t
+ */
+lv_point_t lv_chart_get_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * cursor);
+
+/*=====================
+ * Set/Get value(s)
+ *====================*/
+
+/**
+ * Initialize all data points of a series with a value
+ * @param obj       pointer to chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param value     the new value for all points. `LV_CHART_POINT_NONE` can be used to hide the points.
+ */
+void lv_chart_set_all_value(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t value);
+
+/**
+ * Set the next point's Y value according to the update mode policy.
+ * @param obj       pointer to chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param value     the new value of the next data
+ */
+void lv_chart_set_next_value(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t value);
+
+/**
+ * Set the next point's X and Y value according to the update mode policy.
+ * @param obj       pointer to chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param x_value   the new X value of the next data
+ * @param y_value   the new Y value of the next data
+ */
+void lv_chart_set_next_value2(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t x_value, lv_coord_t y_value);
+
+/**
+ * Set an individual point's y value of a chart's series directly based on its index
+ * @param obj     pointer to a chart object
+ * @param ser     pointer to a data series on 'chart'
+ * @param id      the index of the x point in the array
+ * @param value   value to assign to array point
+ */
+void lv_chart_set_value_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t value);
+
+/**
+ * Set an individual point's x and y value of a chart's series directly based on its index
+ * Can be used only with `LV_CHART_TYPE_SCATTER`.
+ * @param obj       pointer to chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param id        the index of the x point in the array
+ * @param x_value   the new X value of the next data
+ * @param y_value   the new Y value of the next data
+ */
+void lv_chart_set_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t x_value,
+                               lv_coord_t y_value);
+
+/**
+ * Set an external array for the y data points to use for the chart
+ * NOTE: It is the users responsibility to make sure the `point_cnt` matches the external array size.
+ * @param obj       pointer to a chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param array     external array of points for chart
+ */
+void lv_chart_set_ext_y_array(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t array[]);
+
+/**
+ * Set an external array for the x data points to use for the chart
+ * NOTE: It is the users responsibility to make sure the `point_cnt` matches the external array size.
+ * @param obj       pointer to a chart object
+ * @param ser       pointer to a data series on 'chart'
+ * @param array     external array of points for chart
+ */
+void lv_chart_set_ext_x_array(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t array[]);
+
+/**
+ * Get the array of y values of a series
+ * @param obj   pointer to a chart object
+ * @param ser   pointer to a data series on 'chart'
+ * @return      the array of values with 'point_count' elements
+ */
+lv_coord_t * lv_chart_get_y_array(const lv_obj_t * obj, lv_chart_series_t * ser);
+
+/**
+ * Get the array of x values of a series
+ * @param obj   pointer to a chart object
+ * @param ser   pointer to a data series on 'chart'
+ * @return      the array of values with 'point_count' elements
+ */
+lv_coord_t * lv_chart_get_x_array(const lv_obj_t * obj, lv_chart_series_t * ser);
+
+/**
+ * Get the index of the currently pressed point. It's the same for every series.
+ * @param obj       pointer to a chart object
+ * @return          the index of the point [0 .. point count] or LV_CHART_POINT_ID_NONE if no point is being pressed
+ */
+uint32_t lv_chart_get_pressed_point(const lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_CHART*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CHART_H*/

include/liblvgl/extra/widgets/colorwheel/lv_colorwheel.h

@@ -0,0 +1,142 @@
+/**
+ * @file lv_colorwheel.h
+ *
+ */
+
+#ifndef LV_COLORWHEEL_H
+#define LV_COLORWHEEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_COLORWHEEL
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+enum {
+    LV_COLORWHEEL_MODE_HUE,
+    LV_COLORWHEEL_MODE_SATURATION,
+    LV_COLORWHEEL_MODE_VALUE
+};
+typedef uint8_t lv_colorwheel_mode_t;
+
+
+/*Data of color picker*/
+typedef struct {
+    lv_obj_t obj;
+    lv_color_hsv_t hsv;
+    struct {
+        lv_point_t pos;
+        uint8_t recolor     : 1;
+    } knob;
+    uint32_t last_click_time;
+    uint32_t last_change_time;
+    lv_point_t last_press_point;
+    lv_colorwheel_mode_t mode  : 2;
+    uint8_t mode_fixed            : 1;
+} lv_colorwheel_t;
+
+extern const lv_obj_class_t lv_colorwheel_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a color picker object with disc shape
+ * @param parent pointer to an object, it will be the parent of the new color picker
+ * @param knob_recolor true: set the knob's color to the current color
+ * @return pointer to the created color picker
+ */
+lv_obj_t * lv_colorwheel_create(lv_obj_t * parent, bool knob_recolor);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set the current hsv of a color wheel.
+ * @param colorwheel pointer to color wheel object
+ * @param color current selected hsv
+ * @return true if changed, otherwise false
+ */
+bool lv_colorwheel_set_hsv(lv_obj_t * obj, lv_color_hsv_t hsv);
+
+/**
+ * Set the current color of a color wheel.
+ * @param colorwheel pointer to color wheel object
+ * @param color current selected color
+ * @return true if changed, otherwise false
+ */
+bool lv_colorwheel_set_rgb(lv_obj_t * obj, lv_color_t color);
+
+/**
+ * Set the current color mode.
+ * @param colorwheel pointer to color wheel object
+ * @param mode color mode (hue/sat/val)
+ */
+void lv_colorwheel_set_mode(lv_obj_t * obj, lv_colorwheel_mode_t mode);
+
+/**
+ * Set if the color mode is changed on long press on center
+ * @param colorwheel pointer to color wheel object
+ * @param fixed color mode cannot be changed on long press
+ */
+void lv_colorwheel_set_mode_fixed(lv_obj_t * obj, bool fixed);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the current selected hsv of a color wheel.
+ * @param colorwheel pointer to color wheel object
+ * @return current selected hsv
+ */
+lv_color_hsv_t lv_colorwheel_get_hsv(lv_obj_t * obj);
+
+/**
+ * Get the current selected color of a color wheel.
+ * @param colorwheel pointer to color wheel object
+ * @return color current selected color
+ */
+lv_color_t lv_colorwheel_get_rgb(lv_obj_t * obj);
+
+/**
+ * Get the current color mode.
+ * @param colorwheel pointer to color wheel object
+ * @return color mode (hue/sat/val)
+ */
+lv_colorwheel_mode_t lv_colorwheel_get_color_mode(lv_obj_t * obj);
+
+/**
+ * Get if the color mode is changed on long press on center
+ * @param colorwheel pointer to color wheel object
+ * @return mode cannot be changed on long press
+ */
+bool lv_colorwheel_get_color_mode_fixed(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_COLORWHEEL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_COLORWHEEL_H*/
+

include/liblvgl/extra/widgets/imgbtn/lv_imgbtn.h

@@ -0,0 +1,131 @@
+/**
+ * @file lv_imgbtn.h
+ *
+ */
+
+#ifndef LV_IMGBTN_H
+#define LV_IMGBTN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_IMGBTN != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+typedef enum {
+    LV_IMGBTN_STATE_RELEASED,
+    LV_IMGBTN_STATE_PRESSED,
+    LV_IMGBTN_STATE_DISABLED,
+    LV_IMGBTN_STATE_CHECKED_RELEASED,
+    LV_IMGBTN_STATE_CHECKED_PRESSED,
+    LV_IMGBTN_STATE_CHECKED_DISABLED,
+    _LV_IMGBTN_STATE_NUM,
+} lv_imgbtn_state_t;
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+/*Data of image button*/
+typedef struct {
+    lv_obj_t obj;
+    const void * img_src_mid[_LV_IMGBTN_STATE_NUM];   /*Store center images to each state*/
+    const void * img_src_left[_LV_IMGBTN_STATE_NUM];  /*Store left side images to each state*/
+    const void * img_src_right[_LV_IMGBTN_STATE_NUM]; /*Store right side images to each state*/
+    lv_img_cf_t act_cf; /*Color format of the currently active image*/
+} lv_imgbtn_t;
+
+extern const lv_obj_class_t lv_imgbtn_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create an image button object
+ * @param parent pointer to an object, it will be the parent of the new image button
+ * @return pointer to the created image button
+ */
+lv_obj_t * lv_imgbtn_create(lv_obj_t * parent);
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set images for a state of the image button
+ * @param imgbtn pointer to an image button object
+ * @param state for which state set the new image
+ * @param src_left pointer to an image source for the left side of the button (a C array or path to
+ * a file)
+ * @param src_mid pointer to an image source for the middle of the button (ideally 1px wide) (a C
+ * array or path to a file)
+ * @param src_right pointer to an image source for the right side of the button (a C array or path
+ * to a file)
+ */
+void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src_left, const void * src_mid,
+                       const void * src_right);
+
+
+/**
+ * Use this function instead of `lv_obj_add/clear_state` to set a state manually
+ * @param imgbtn pointer to an image button object
+ * @param state  the new state
+ */
+void lv_imgbtn_set_state(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the left image in a given state
+ * @param imgbtn pointer to an image button object
+ * @param state the state where to get the image (from `lv_btn_state_t`) `
+ * @return pointer to the left image source (a C array or path to a file)
+ */
+const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
+
+/**
+ * Get the middle image in a given state
+ * @param imgbtn pointer to an image button object
+ * @param state the state where to get the image (from `lv_btn_state_t`) `
+ * @return pointer to the middle image source (a C array or path to a file)
+ */
+const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
+
+/**
+ * Get the right image in a given state
+ * @param imgbtn pointer to an image button object
+ * @param state the state where to get the image (from `lv_btn_state_t`) `
+ * @return pointer to the left image source (a C array or path to a file)
+ */
+const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
+
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_IMGBTN*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_IMGBTN_H*/

include/liblvgl/extra/widgets/keyboard/lv_keyboard.h

@@ -0,0 +1,187 @@
+/**
+ * @file lv_keyboard.h
+ *
+ */
+
+#ifndef LV_KEYBOARD_H
+#define LV_KEYBOARD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/widgets/lv_btnmatrix.h"
+
+#if LV_USE_KEYBOARD
+
+/*Testing of dependencies*/
+#if LV_USE_BTNMATRIX == 0
+#error "lv_kb: lv_btnm is required. Enable it in lv_conf.h (LV_USE_BTNMATRIX  1) "
+#endif
+
+#if LV_USE_TEXTAREA == 0
+#error "lv_kb: lv_ta is required. Enable it in lv_conf.h (LV_USE_TEXTAREA  1) "
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_KEYBOARD_CTRL_BTN_FLAGS (LV_BTNMATRIX_CTRL_NO_REPEAT | LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_CHECKED)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/** Current keyboard mode.*/
+enum {
+    LV_KEYBOARD_MODE_TEXT_LOWER,
+    LV_KEYBOARD_MODE_TEXT_UPPER,
+    LV_KEYBOARD_MODE_SPECIAL,
+    LV_KEYBOARD_MODE_NUMBER,
+    LV_KEYBOARD_MODE_USER_1,
+    LV_KEYBOARD_MODE_USER_2,
+    LV_KEYBOARD_MODE_USER_3,
+    LV_KEYBOARD_MODE_USER_4,
+};
+typedef uint8_t lv_keyboard_mode_t;
+
+/*Data of keyboard*/
+typedef struct {
+    lv_btnmatrix_t btnm;
+    lv_obj_t * ta;              /*Pointer to the assigned text area*/
+    lv_keyboard_mode_t mode;    /*Key map type*/
+    uint8_t popovers : 1;       /*Show button titles in popovers on press*/
+} lv_keyboard_t;
+
+extern const lv_obj_class_t lv_keyboard_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a Keyboard object
+ * @param parent pointer to an object, it will be the parent of the new keyboard
+ * @return pointer to the created keyboard
+ */
+lv_obj_t * lv_keyboard_create(lv_obj_t * parent);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Assign a Text Area to the Keyboard. The pressed characters will be put there.
+ * @param kb pointer to a Keyboard object
+ * @param ta pointer to a Text Area object to write there
+ */
+void lv_keyboard_set_textarea(lv_obj_t * kb, lv_obj_t * ta);
+
+/**
+ * Set a new a mode (text or number map)
+ * @param kb pointer to a Keyboard object
+ * @param mode the mode from 'lv_keyboard_mode_t'
+ */
+void lv_keyboard_set_mode(lv_obj_t * kb, lv_keyboard_mode_t mode);
+
+/**
+ * Show the button title in a popover when pressed.
+ * @param kb pointer to a Keyboard object
+ * @param en whether "popovers" mode is enabled
+ */
+void lv_keyboard_set_popovers(lv_obj_t * kb, bool en);
+
+/**
+ * Set a new map for the keyboard
+ * @param kb pointer to a Keyboard object
+ * @param mode keyboard map to alter 'lv_keyboard_mode_t'
+ * @param map pointer to a string array to describe the map.
+ *            See 'lv_btnmatrix_set_map()' for more info.
+ */
+void lv_keyboard_set_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const char * map[],
+                         const lv_btnmatrix_ctrl_t ctrl_map[]);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Assign a Text Area to the Keyboard. The pressed characters will be put there.
+ * @param kb pointer to a Keyboard object
+ * @return pointer to the assigned Text Area object
+ */
+lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * kb);
+
+/**
+ * Set a new a mode (text or number map)
+ * @param kb pointer to a Keyboard object
+ * @return the current mode from 'lv_keyboard_mode_t'
+ */
+lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * kb);
+
+/**
+ * Tell whether "popovers" mode is enabled or not.
+ * @param kb pointer to a Keyboard object
+ * @return true: "popovers" mode is enabled; false: disabled
+ */
+bool lv_btnmatrix_get_popovers(const lv_obj_t * obj);
+
+/**
+ * Get the current map of a keyboard
+ * @param kb pointer to a keyboard object
+ * @return the current map
+ */
+static inline const char ** lv_keyboard_get_map_array(const lv_obj_t * kb)
+{
+    return lv_btnmatrix_get_map(kb);
+}
+
+/**
+ * Get the index of the lastly "activated" button by the user (pressed, released, focused etc)
+ * Useful in the `event_cb` to get the text of the button, check if hidden etc.
+ * @param obj       pointer to button matrix object
+ * @return          index of the last released button (LV_BTNMATRIX_BTN_NONE: if unset)
+ */
+static inline uint16_t lv_keyboard_get_selected_btn(const lv_obj_t * obj)
+{
+    return lv_btnmatrix_get_selected_btn(obj);
+}
+
+/**
+ * Get the button's text
+ * @param obj       pointer to button matrix object
+ * @param btn_id    the index a button not counting new line characters.
+ * @return          text of btn_index` button
+ */
+static inline const char * lv_keyboard_get_btn_text(const lv_obj_t * obj, uint16_t btn_id)
+{
+    return lv_btnmatrix_get_btn_text(obj, btn_id);
+}
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**
+ * Default keyboard event to add characters to the Text area and change the map.
+ * If a custom `event_cb` is added to the keyboard this function can be called from it to handle the
+ * button clicks
+ * @param kb pointer to a keyboard
+ * @param event the triggering event
+ */
+void lv_keyboard_def_event_cb(lv_event_t * e);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_KEYBOARD*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_KEYBOARD_H*/

include/liblvgl/extra/widgets/led/lv_led.h

@@ -0,0 +1,116 @@
+/**
+ * @file lv_led.h
+ *
+ */
+
+#ifndef LV_LED_H
+#define LV_LED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_LED
+
+
+/*********************
+ *      DEFINES
+ *********************/
+/** Brightness when the LED if OFF */
+#ifndef LV_LED_BRIGHT_MIN
+# define LV_LED_BRIGHT_MIN 80
+#endif
+
+/** Brightness when the LED if ON */
+#ifndef LV_LED_BRIGHT_MAX
+# define LV_LED_BRIGHT_MAX 255
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Data of led*/
+typedef struct {
+    lv_obj_t obj;
+    lv_color_t color;
+    uint8_t bright;     /**< Current brightness of the LED (0..255)*/
+} lv_led_t;
+
+extern const lv_obj_class_t lv_led_class;
+
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_led_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_LED_DRAW_PART_RECTANGLE,    /**< The main rectangle*/
+} lv_led_draw_part_type_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a led object
+ * @param parent pointer to an object, it will be the parent of the new led
+ * @return pointer to the created led
+ */
+lv_obj_t * lv_led_create(lv_obj_t * parent);
+
+/**
+ * Set the color of the LED
+ * @param led       pointer to a LED object
+ * @param color     the color of the LED
+ */
+void lv_led_set_color(lv_obj_t * led, lv_color_t color);
+
+/**
+ * Set the brightness of a LED object
+ * @param led pointer to a LED object
+ * @param bright LV_LED_BRIGHT_MIN (max. dark) ... LV_LED_BRIGHT_MAX (max. light)
+ */
+void lv_led_set_brightness(lv_obj_t * led, uint8_t bright);
+
+/**
+ * Light on a LED
+ * @param led pointer to a LED object
+ */
+void lv_led_on(lv_obj_t * led);
+
+/**
+ * Light off a LED
+ * @param led pointer to a LED object
+ */
+void lv_led_off(lv_obj_t * led);
+
+/**
+ * Toggle the state of a LED
+ * @param led pointer to a LED object
+ */
+void lv_led_toggle(lv_obj_t * led);
+
+/**
+ * Get the brightness of a LEd object
+ * @param led pointer to LED object
+ * @return bright 0 (max. dark) ... 255 (max. light)
+ */
+uint8_t lv_led_get_brightness(const lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_LED*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+
+#endif /*LV_LED_H*/

include/liblvgl/extra/widgets/list/lv_list.h

@@ -0,0 +1,54 @@
+/**
+ * @file lv_win.h
+ *
+ */
+
+#ifndef LV_LIST_H
+#define LV_LIST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+#include "liblvgl/extra/layouts/flex/lv_flex.h"
+
+#if LV_USE_LIST
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+extern const lv_obj_class_t lv_list_class;
+extern const lv_obj_class_t lv_list_text_class;
+extern const lv_obj_class_t lv_list_btn_class;
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_list_create(lv_obj_t * parent);
+
+lv_obj_t * lv_list_add_text(lv_obj_t * list, const char * txt);
+
+lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * icon, const char * txt);
+
+const char * lv_list_get_btn_text(lv_obj_t * list, lv_obj_t * btn);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_LIST*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LIST_H*/

include/liblvgl/extra/widgets/lv_widgets.h

@@ -0,0 +1,56 @@
+/**
+ * @file lv_widgets.h
+ *
+ */
+
+#ifndef LV_WIDGETS_H
+#define LV_WIDGETS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "animimg/lv_animimg.h"
+#include "calendar/lv_calendar.h"
+#include "calendar/lv_calendar_header_arrow.h"
+#include "calendar/lv_calendar_header_dropdown.h"
+#include "chart/lv_chart.h"
+#include "keyboard/lv_keyboard.h"
+#include "list/lv_list.h"
+#include "menu/lv_menu.h"
+#include "msgbox/lv_msgbox.h"
+#include "meter/lv_meter.h"
+#include "spinbox/lv_spinbox.h"
+#include "spinner/lv_spinner.h"
+#include "tabview/lv_tabview.h"
+#include "tileview/lv_tileview.h"
+#include "win/lv_win.h"
+#include "colorwheel/lv_colorwheel.h"
+#include "led/lv_led.h"
+#include "imgbtn/lv_imgbtn.h"
+#include "span/lv_span.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_WIDGETS_H*/

include/liblvgl/extra/widgets/menu/lv_menu.h

@@ -0,0 +1,233 @@
+/**
+ * @file lv_menu.h
+ *
+ */
+
+#ifndef LV_MENU_H
+#define LV_MENU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_MENU
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+enum {
+    LV_MENU_HEADER_TOP_FIXED, /* Header is positioned at the top */
+    LV_MENU_HEADER_TOP_UNFIXED, /* Header is positioned at the top and can be scrolled out of view*/
+    LV_MENU_HEADER_BOTTOM_FIXED /* Header is positioned at the bottom */
+};
+typedef uint8_t lv_menu_mode_header_t;
+
+enum {
+    LV_MENU_ROOT_BACK_BTN_DISABLED,
+    LV_MENU_ROOT_BACK_BTN_ENABLED
+};
+typedef uint8_t lv_menu_mode_root_back_btn_t;
+
+typedef struct lv_menu_load_page_event_data_t {
+    lv_obj_t * menu;
+    lv_obj_t * page;
+} lv_menu_load_page_event_data_t;
+
+typedef struct {
+    lv_obj_t * page;
+} lv_menu_history_t;
+
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * storage; /* a pointer to obj that is the parent of all pages not displayed */
+    lv_obj_t * main;
+    lv_obj_t * main_page;
+    lv_obj_t * main_header;
+    lv_obj_t *
+    main_header_back_btn; /* a pointer to obj that on click triggers back btn event handler, can be same as 'main_header' */
+    lv_obj_t * main_header_title;
+    lv_obj_t * sidebar;
+    lv_obj_t * sidebar_page;
+    lv_obj_t * sidebar_header;
+    lv_obj_t *
+    sidebar_header_back_btn; /* a pointer to obj that on click triggers back btn event handler, can be same as 'sidebar_header' */
+    lv_obj_t * sidebar_header_title;
+    lv_obj_t * selected_tab;
+    lv_ll_t history_ll;
+    uint8_t cur_depth;
+    uint8_t prev_depth;
+    uint8_t sidebar_generated : 1;
+    lv_menu_mode_header_t mode_header : 2;
+    lv_menu_mode_root_back_btn_t mode_root_back_btn : 1;
+} lv_menu_t;
+
+typedef struct {
+    lv_obj_t obj;
+    char * title;
+} lv_menu_page_t;
+
+extern const lv_obj_class_t lv_menu_class;
+extern const lv_obj_class_t lv_menu_page_class;
+extern const lv_obj_class_t lv_menu_cont_class;
+extern const lv_obj_class_t lv_menu_section_class;
+extern const lv_obj_class_t lv_menu_separator_class;
+extern const lv_obj_class_t lv_menu_sidebar_cont_class;
+extern const lv_obj_class_t lv_menu_main_cont_class;
+extern const lv_obj_class_t lv_menu_sidebar_header_cont_class;
+extern const lv_obj_class_t lv_menu_main_header_cont_class;
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a menu object
+ * @param parent pointer to an object, it will be the parent of the new menu
+ * @return pointer to the created menu
+ */
+lv_obj_t * lv_menu_create(lv_obj_t * parent);
+
+/**
+ * Create a menu page object
+ * @param parent pointer to menu object
+ * @param title pointer to text for title in header (NULL to not display title)
+ * @return pointer to the created menu page
+ */
+lv_obj_t * lv_menu_page_create(lv_obj_t * parent, char * title);
+
+/**
+ * Create a menu cont object
+ * @param parent pointer to an object, it will be the parent of the new menu cont object
+ * @return pointer to the created menu cont
+ */
+lv_obj_t * lv_menu_cont_create(lv_obj_t * parent);
+
+/**
+ * Create a menu section object
+ * @param parent pointer to an object, it will be the parent of the new menu section object
+ * @return pointer to the created menu section
+ */
+lv_obj_t * lv_menu_section_create(lv_obj_t * parent);
+
+/**
+ * Create a menu separator object
+ * @param parent pointer to an object, it will be the parent of the new menu separator object
+ * @return pointer to the created menu separator
+ */
+lv_obj_t * lv_menu_separator_create(lv_obj_t * parent);
+/*=====================
+ * Setter functions
+ *====================*/
+/**
+ * Set menu page to display in main
+ * @param obj pointer to the menu
+ * @param page pointer to the menu page to set (NULL to clear main and clear menu history)
+ */
+void lv_menu_set_page(lv_obj_t * obj, lv_obj_t * page);
+
+/**
+ * Set menu page to display in sidebar
+ * @param obj pointer to the menu
+ * @param page pointer to the menu page to set (NULL to clear sidebar)
+ */
+void lv_menu_set_sidebar_page(lv_obj_t * obj, lv_obj_t * page);
+
+/**
+ * Set the how the header should behave and its position
+ * @param obj pointer to a menu
+ * @param mode_header
+ */
+void lv_menu_set_mode_header(lv_obj_t * obj, lv_menu_mode_header_t mode_header);
+
+/**
+ * Set whether back button should appear at root
+ * @param obj pointer to a menu
+ * @param mode_root_back_btn
+ */
+void lv_menu_set_mode_root_back_btn(lv_obj_t * obj, lv_menu_mode_root_back_btn_t mode_root_back_btn);
+
+/**
+ * Add menu to the menu item
+ * @param menu pointer to the menu
+ * @param obj pointer to the obj
+ * @param page pointer to the page to load when obj is clicked
+ */
+void lv_menu_set_load_page_event(lv_obj_t * menu, lv_obj_t * obj, lv_obj_t * page);
+
+/*=====================
+ * Getter functions
+ *====================*/
+/**
+* Get a pointer to menu page that is currently displayed in main
+* @param obj pointer to the menu
+* @return pointer to current page
+*/
+lv_obj_t * lv_menu_get_cur_main_page(lv_obj_t * obj);
+
+/**
+* Get a pointer to menu page that is currently displayed in sidebar
+* @param obj pointer to the menu
+* @return pointer to current page
+*/
+lv_obj_t * lv_menu_get_cur_sidebar_page(lv_obj_t * obj);
+
+/**
+* Get a pointer to main header obj
+* @param obj pointer to the menu
+* @return pointer to main header obj
+*/
+lv_obj_t * lv_menu_get_main_header(lv_obj_t * obj);
+
+/**
+* Get a pointer to main header back btn obj
+* @param obj pointer to the menu
+* @return pointer to main header back btn obj
+*/
+lv_obj_t * lv_menu_get_main_header_back_btn(lv_obj_t * obj);
+
+/**
+* Get a pointer to sidebar header obj
+* @param obj pointer to the menu
+* @return pointer to sidebar header obj
+*/
+lv_obj_t * lv_menu_get_sidebar_header(lv_obj_t * obj);
+
+/**
+* Get a pointer to sidebar header obj
+* @param obj pointer to the menu
+* @return pointer to sidebar header back btn obj
+*/
+lv_obj_t * lv_menu_get_sidebar_header_back_btn(lv_obj_t * obj);
+
+/**
+ * Check if an obj is a root back btn
+ * @param menu pointer to the menu
+ * @return true if it is a root back btn
+ */
+bool lv_menu_back_btn_is_root(lv_obj_t * menu, lv_obj_t * obj);
+
+/**
+ * Clear menu history
+ * @param obj pointer to the menu
+ */
+void lv_menu_clear_history(lv_obj_t * obj);
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_MENU*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_MENU_H*/

include/liblvgl/extra/widgets/meter/lv_meter.h

@@ -0,0 +1,267 @@
+/**
+ * @file lv_meter.h
+ *
+ */
+
+#ifndef LV_METER_H
+#define LV_METER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_METER != 0
+
+/*Testing of dependencies*/
+#if LV_DRAW_COMPLEX == 0
+#error "lv_meter: Complex drawing is required. Enable it in lv_conf.h (LV_DRAW_COMPLEX 1)"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_color_t tick_color;
+    uint16_t tick_cnt;
+    uint16_t tick_length;
+    uint16_t tick_width;
+
+    lv_color_t tick_major_color;
+    uint16_t tick_major_nth;
+    uint16_t tick_major_length;
+    uint16_t tick_major_width;
+
+    int16_t label_gap;
+    int16_t label_color;
+
+    int32_t min;
+    int32_t max;
+    int16_t r_mod;
+    uint16_t angle_range;
+    int16_t rotation;
+} lv_meter_scale_t;
+
+enum {
+    LV_METER_INDICATOR_TYPE_NEEDLE_IMG,
+    LV_METER_INDICATOR_TYPE_NEEDLE_LINE,
+    LV_METER_INDICATOR_TYPE_SCALE_LINES,
+    LV_METER_INDICATOR_TYPE_ARC,
+};
+typedef uint8_t lv_meter_indicator_type_t;
+
+typedef struct {
+    lv_meter_scale_t * scale;
+    lv_meter_indicator_type_t type;
+    lv_opa_t opa;
+    int32_t start_value;
+    int32_t end_value;
+    union {
+        struct {
+            const void * src;
+            lv_point_t pivot;
+        } needle_img;
+        struct {
+            uint16_t width;
+            int16_t r_mod;
+            lv_color_t color;
+        } needle_line;
+        struct {
+            uint16_t width;
+            const void * src;
+            lv_color_t color;
+            int16_t r_mod;
+        } arc;
+        struct {
+            int16_t width_mod;
+            lv_color_t color_start;
+            lv_color_t color_end;
+            uint8_t local_grad  : 1;
+        } scale_lines;
+    } type_data;
+} lv_meter_indicator_t;
+
+/*Data of line meter*/
+typedef struct {
+    lv_obj_t obj;
+    lv_ll_t scale_ll;
+    lv_ll_t indicator_ll;
+} lv_meter_t;
+
+extern const lv_obj_class_t lv_meter_class;
+
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_meter_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_METER_DRAW_PART_ARC,             /**< The arc indicator*/
+    LV_METER_DRAW_PART_NEEDLE_LINE,     /**< The needle lines*/
+    LV_METER_DRAW_PART_NEEDLE_IMG,      /**< The needle images*/
+    LV_METER_DRAW_PART_TICK,            /**< The tick lines and labels*/
+} lv_meter_draw_part_type_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a Meter object
+ * @param parent pointer to an object, it will be the parent of the new bar.
+ * @return pointer to the created meter
+ */
+lv_obj_t * lv_meter_create(lv_obj_t * parent);
+
+/*=====================
+ * Add scale
+ *====================*/
+
+/**
+ * Add a new scale to the meter.
+ * @param obj   pointer to a meter object
+ * @return      the new scale
+ * @note        Indicators can be attached to scales.
+ */
+lv_meter_scale_t * lv_meter_add_scale(lv_obj_t * obj);
+
+/**
+ * Set the properties of the ticks of a scale
+ * @param obj       pointer to a meter object
+ * @param scale     pointer to scale (added to `meter`)
+ * @param cnt       number of tick lines
+ * @param width     width of tick lines
+ * @param len       length of tick lines
+ * @param color     color of tick lines
+ */
+void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t cnt, uint16_t width, uint16_t len,
+                              lv_color_t color);
+
+/**
+ * Make some "normal" ticks major ticks and set their attributes.
+ * Texts with the current value are also added to the major ticks.
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param nth           make every Nth normal tick major tick. (start from the first on the left)
+ * @param width         width of the major ticks
+ * @param len           length of the major ticks
+ * @param color         color of the major ticks
+ * @param label_gap     gap between the major ticks and the labels
+ */
+void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t nth, uint16_t width,
+                                    uint16_t len, lv_color_t color, int16_t label_gap);
+
+/**
+ * Set the value and angular range of a scale.
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param min           the minimum value
+ * @param max           the maximal value
+ * @param angle_range   the angular range of the scale
+ * @param rotation      the angular offset from the 3 o'clock position (clock-wise)
+ */
+void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t min, int32_t max, uint32_t angle_range,
+                              uint32_t rotation);
+
+/*=====================
+ * Add indicator
+ *====================*/
+
+/**
+ * Add a needle line indicator the scale
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param width         width of the line
+ * @param color         color of the line
+ * @param r_mod         the radius modifier (added to the scale's radius) to get the lines length
+ * @return              the new indicator
+ */
+lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width,
+                                                lv_color_t color, int16_t r_mod);
+
+/**
+ * Add a needle image indicator the scale
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param src           the image source of the indicator. path or pointer to ::lv_img_dsc_t
+ * @param pivot_x       the X pivot point of the needle
+ * @param pivot_y       the Y pivot point of the needle
+ * @return              the new indicator
+ * @note                the needle image should point to the right, like -O----->
+ */
+lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t * scale, const void * src,
+                                               lv_coord_t pivot_x, lv_coord_t pivot_y);
+
+/**
+ * Add an arc indicator the scale
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param width         width of the arc
+ * @param color         color of the arc
+ * @param r_mod         the radius modifier (added to the scale's radius) to get the outer radius of the arc
+ * @return              the new indicator
+ */
+lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color,
+                                        int16_t r_mod);
+
+
+/**
+ * Add a scale line indicator the scale. It will modify the ticks.
+ * @param obj           pointer to a meter object
+ * @param scale         pointer to scale (added to `meter`)
+ * @param color_start   the start color
+ * @param color_end     the end color
+ * @param local         tell how to map start and end color. true: the indicator's start and end_value; false: the scale's min max value
+ * @param width_mod     add this the affected tick's width
+ * @return              the new indicator
+ */
+lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t * scale, lv_color_t color_start,
+                                                lv_color_t color_end, bool local, int16_t width_mod);
+
+/*=====================
+ * Set indicator value
+ *====================*/
+
+/**
+ * Set the value of the indicator. It will set start and and value to the same value
+ * @param obj           pointer to a meter object
+ * @param indic         pointer to an indicator
+ * @param value         the new value
+ */
+void lv_meter_set_indicator_value(lv_obj_t * obj, lv_meter_indicator_t * indic, int32_t value);
+
+/**
+ * Set the start value of the indicator.
+ * @param obj           pointer to a meter object
+ * @param indic         pointer to an indicator
+ * @param value         the new value
+ */
+void lv_meter_set_indicator_start_value(lv_obj_t * obj, lv_meter_indicator_t * indic, int32_t value);
+
+/**
+ * Set the start value of the indicator.
+ * @param obj           pointer to a meter object
+ * @param indic         pointer to an indicator
+ * @param value         the new value
+ */
+void lv_meter_set_indicator_end_value(lv_obj_t * obj, lv_meter_indicator_t * indic, int32_t value);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_METER*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_METER_H*/

include/liblvgl/extra/widgets/msgbox/lv_msgbox.h

@@ -0,0 +1,99 @@
+/**
+ * @file lv_mbox.h
+ *
+ */
+
+#ifndef LV_MSGBOX_H
+#define LV_MSGBOX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_MSGBOX
+
+/*Testing of dependencies*/
+#if LV_USE_BTNMATRIX == 0
+#error "lv_mbox: lv_btnm is required. Enable it in lv_conf.h (LV_USE_BTNMATRIX  1) "
+#endif
+
+#if LV_USE_LABEL == 0
+#error "lv_mbox: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * title;
+    lv_obj_t * close_btn;
+    lv_obj_t * content;
+    lv_obj_t * text;
+    lv_obj_t * btns;
+} lv_msgbox_t;
+
+extern const lv_obj_class_t lv_msgbox_class;
+extern const lv_obj_class_t lv_msgbox_content_class;
+extern const lv_obj_class_t lv_msgbox_backdrop_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a message box object
+ * @param parent        pointer to parent or NULL to create a full screen modal message box
+ * @param title         the title of the message box
+ * @param txt           the text of the message box
+ * @param btn_txts      the buttons as an array of texts terminated by an "" element. E.g. {"btn1", "btn2", ""}
+ * @param add_close_btn true: add a close button
+ * @return              pointer to the message box object
+ */
+lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[],
+                            bool add_close_btn);
+
+lv_obj_t * lv_msgbox_get_title(lv_obj_t * obj);
+
+lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * obj);
+
+lv_obj_t * lv_msgbox_get_text(lv_obj_t * obj);
+
+lv_obj_t * lv_msgbox_get_content(lv_obj_t * obj);
+
+lv_obj_t * lv_msgbox_get_btns(lv_obj_t * obj);
+
+/**
+ * Get the index of the selected button
+ * @param mbox message box object
+ * @return     index of the button (LV_BTNMATRIX_BTN_NONE: if unset)
+ */
+uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox);
+
+const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox);
+
+void lv_msgbox_close(lv_obj_t * mbox);
+
+void lv_msgbox_close_async(lv_obj_t * mbox);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_MSGBOX*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_MSGBOX_H*/

include/liblvgl/extra/widgets/span/lv_span.h

@@ -0,0 +1,245 @@
+/**
+ * @file lv_span.h
+ *
+ */
+
+#ifndef LV_SPAN_H
+#define LV_SPAN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_SPAN != 0
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifndef LV_SPAN_SNIPPET_STACK_SIZE
+#define LV_SPAN_SNIPPET_STACK_SIZE 64
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum {
+    LV_SPAN_OVERFLOW_CLIP,
+    LV_SPAN_OVERFLOW_ELLIPSIS,
+};
+typedef uint8_t lv_span_overflow_t;
+
+enum {
+    LV_SPAN_MODE_FIXED,     /**< fixed the obj size*/
+    LV_SPAN_MODE_EXPAND,    /**< Expand the object size to the text size*/
+    LV_SPAN_MODE_BREAK,     /**< Keep width, break the too long lines and expand height*/
+};
+typedef uint8_t lv_span_mode_t;
+
+typedef struct {
+    char * txt;             /* a pointer to display text */
+    lv_obj_t * spangroup;   /* a pointer to spangroup */
+    lv_style_t style;       /* display text style */
+    uint8_t static_flag : 1;/* the text is static flag */
+} lv_span_t;
+
+/** Data of label*/
+typedef struct {
+    lv_obj_t obj;
+    int32_t lines;
+    lv_coord_t indent;      /* first line indent */
+    lv_coord_t cache_w;     /* the cache automatically calculates the width */
+    lv_coord_t cache_h;     /* similar cache_w */
+    lv_ll_t  child_ll;
+    uint8_t mode : 2;       /* details see lv_span_mode_t */
+    uint8_t overflow : 1;   /* details see lv_span_overflow_t */
+    uint8_t refresh : 1;    /* the spangroup need refresh cache_w and cache_h */
+} lv_spangroup_t;
+
+extern const lv_obj_class_t lv_spangroup_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a spangroup object
+ * @param par pointer to an object, it will be the parent of the new spangroup
+ * @return pointer to the created spangroup
+ */
+lv_obj_t * lv_spangroup_create(lv_obj_t * par);
+
+/**
+ * Create a span string descriptor and add to spangroup.
+ * @param obj pointer to a spangroup object.
+ * @return pointer to the created span.
+ */
+lv_span_t * lv_spangroup_new_span(lv_obj_t * obj);
+
+/**
+ * Remove the span from the spangroup and free memory.
+ * @param obj pointer to a spangroup object.
+ * @param span pointer to a span.
+ */
+void lv_spangroup_del_span(lv_obj_t * obj, lv_span_t * span);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set a new text for a span. Memory will be allocated to store the text by the span.
+ * @param span pointer to a span.
+ * @param text pointer to a text.
+ */
+void lv_span_set_text(lv_span_t * span, const char * text);
+
+/**
+ * Set a static text. It will not be saved by the span so the 'text' variable
+ * has to be 'alive' while the span exist.
+ * @param span pointer to a span.
+ * @param text pointer to a text.
+ */
+void lv_span_set_text_static(lv_span_t * span, const char * text);
+
+/**
+ * Set the align of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @param align see lv_text_align_t for details.
+ */
+void lv_spangroup_set_align(lv_obj_t * obj, lv_text_align_t align);
+
+/**
+ * Set the overflow of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @param overflow see lv_span_overflow_t for details.
+ */
+void lv_spangroup_set_overflow(lv_obj_t * obj, lv_span_overflow_t overflow);
+
+/**
+ * Set the indent of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @param indent The first line indentation
+ */
+void lv_spangroup_set_indent(lv_obj_t * obj, lv_coord_t indent);
+
+/**
+ * Set the mode of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @param mode see lv_span_mode_t for details.
+ */
+void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode);
+
+/**
+ * Set lines of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @param lines max lines that can be displayed in LV_SPAN_MODE_BREAK mode. < 0 means no limit.
+ */
+void lv_spangroup_set_lines(lv_obj_t * obj, int32_t lines);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get a spangroup child by its index.
+ *
+ * @param obj   The spangroup object
+ * @param id    the index of the child.
+ *              0: the oldest (firstly created) child
+ *              1: the second oldest
+ *              child count-1: the youngest
+ *              -1: the youngest
+ *              -2: the second youngest
+ * @return      The child span at index `id`, or NULL if the ID does not exist
+ */
+lv_span_t * lv_spangroup_get_child(const lv_obj_t * obj, int32_t id);
+
+/**
+ *
+ * @param obj   The spangroup object to get the child count of.
+ * @return      The span count of the spangroup.
+ */
+uint32_t lv_spangroup_get_child_cnt(const lv_obj_t * obj);
+
+/**
+ * get the align of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @return the align value.
+ */
+lv_text_align_t lv_spangroup_get_align(lv_obj_t * obj);
+
+/**
+ * get the overflow of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @return the overflow value.
+ */
+lv_span_overflow_t lv_spangroup_get_overflow(lv_obj_t * obj);
+
+/**
+ * get the indent of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @return the indent value.
+ */
+lv_coord_t lv_spangroup_get_indent(lv_obj_t * obj);
+
+/**
+ * get the mode of the spangroup.
+ * @param obj pointer to a spangroup object.
+ */
+lv_span_mode_t lv_spangroup_get_mode(lv_obj_t * obj);
+
+/**
+ * get lines of the spangroup.
+ * @param obj pointer to a spangroup object.
+ * @return the lines value.
+ */
+int32_t lv_spangroup_get_lines(lv_obj_t * obj);
+
+/**
+ * get max line height of all span in the spangroup.
+ * @param obj pointer to a spangroup object.
+ */
+lv_coord_t lv_spangroup_get_max_line_h(lv_obj_t * obj);
+
+/**
+ * get the text content width when all span of spangroup on a line.
+ * @param obj pointer to a spangroup object.
+ * @param max_width if text content width >= max_width, return max_width
+ * to reduce computation, if max_width == 0, returns the text content width.
+ * @return text content width or max_width.
+ */
+uint32_t lv_spangroup_get_expand_width(lv_obj_t * obj, uint32_t max_width);
+
+/**
+ * get the text content height with width fixed.
+ * @param obj pointer to a spangroup object.
+ */
+lv_coord_t lv_spangroup_get_expand_height(lv_obj_t * obj, lv_coord_t width);
+
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**
+ * update the mode of the spangroup.
+ * @param obj pointer to a spangroup object.
+ */
+void lv_spangroup_refr_mode(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_SPAN*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_SPAN_H*/

include/liblvgl/extra/widgets/spinbox/lv_spinbox.h

@@ -0,0 +1,182 @@
+/**
+ * @file lv_spinbox.h
+ *
+ */
+
+#ifndef LV_SPINBOX_H
+#define LV_SPINBOX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_SPINBOX
+
+/*Testing of dependencies*/
+#if LV_USE_TEXTAREA == 0
+#error "lv_spinbox: lv_ta is required. Enable it in lv_conf.h (LV_USE_TEXTAREA  1) "
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_SPINBOX_MAX_DIGIT_COUNT 10
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Data of spinbox*/
+typedef struct {
+    lv_textarea_t ta;   /*Ext. of ancestor*/
+    /*New data for this type*/
+    int32_t value;
+    int32_t range_max;
+    int32_t range_min;
+    int32_t step;
+    uint16_t digit_count : 4;
+    uint16_t dec_point_pos : 4; /*if 0, there is no separator and the number is an integer*/
+    uint16_t rollover : 1;   // Set to true for rollover functionality
+    uint16_t digit_step_dir : 2; // the direction the digit will step on encoder button press when editing
+} lv_spinbox_t;
+
+extern const lv_obj_class_t lv_spinbox_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a Spinbox object
+ * @param parent pointer to an object, it will be the parent of the new spinbox
+ * @return pointer to the created spinbox
+ */
+lv_obj_t * lv_spinbox_create(lv_obj_t * parent);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set spinbox value
+ * @param obj pointer to spinbox
+ * @param i value to be set
+ */
+void lv_spinbox_set_value(lv_obj_t * obj, int32_t i);
+
+/**
+ * Set spinbox rollover function
+ * @param obj pointer to spinbox
+ * @param b true or false to enable or disable (default)
+ */
+void lv_spinbox_set_rollover(lv_obj_t * obj, bool b);
+
+/**
+ * Set spinbox digit format (digit count and decimal format)
+ * @param obj pointer to spinbox
+ * @param digit_count number of digit excluding the decimal separator and the sign
+ * @param separator_position number of digit before the decimal point. If 0, decimal point is not
+ * shown
+ */
+void lv_spinbox_set_digit_format(lv_obj_t * obj, uint8_t digit_count, uint8_t separator_position);
+
+/**
+ * Set spinbox step
+ * @param obj pointer to spinbox
+ * @param step steps on increment/decrement. Can be 1, 10, 100, 1000, etc the digit that will change.
+ */
+void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step);
+
+/**
+ * Set spinbox value range
+ * @param obj pointer to spinbox
+ * @param range_min maximum value, inclusive
+ * @param range_max minimum value, inclusive
+ */
+void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max);
+
+/**
+ * Set cursor position to a specific digit for edition
+ * @param obj pointer to spinbox
+ * @param pos selected position in spinbox
+ */
+void lv_spinbox_set_cursor_pos(lv_obj_t * obj, uint8_t pos);
+
+/**
+ * Set direction of digit step when clicking an encoder button while in editing mode
+ * @param obj pointer to spinbox
+ * @param direction the direction (LV_DIR_RIGHT or LV_DIR_LEFT)
+ */
+void lv_spinbox_set_digit_step_direction(lv_obj_t * obj, lv_dir_t direction);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get spinbox rollover function status
+ * @param obj pointer to spinbox
+ */
+bool lv_spinbox_get_rollover(lv_obj_t * obj);
+
+/**
+ * Get the spinbox numeral value (user has to convert to float according to its digit format)
+ * @param obj pointer to spinbox
+ * @return value integer value of the spinbox
+ */
+int32_t lv_spinbox_get_value(lv_obj_t * obj);
+
+/**
+ * Get the spinbox step value (user has to convert to float according to its digit format)
+ * @param obj pointer to spinbox
+ * @return value integer step value of the spinbox
+ */
+int32_t lv_spinbox_get_step(lv_obj_t * obj);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**
+ * Select next lower digit for edition by dividing the step by 10
+ * @param obj pointer to spinbox
+ */
+void lv_spinbox_step_next(lv_obj_t * obj);
+
+/**
+ * Select next higher digit for edition by multiplying the step by 10
+ * @param obj pointer to spinbox
+ */
+void lv_spinbox_step_prev(lv_obj_t * obj);
+
+/**
+ * Increment spinbox value by one step
+ * @param obj pointer to spinbox
+ */
+void lv_spinbox_increment(lv_obj_t * obj);
+
+/**
+ * Decrement spinbox value by one step
+ * @param obj pointer to spinbox
+ */
+void lv_spinbox_decrement(lv_obj_t * obj);
+
+/**********************
+ *      MACROS
+ **********************/
+
+/* It was ambiguous in MicroPython. See https://github.com/lvgl/lvgl/issues/3301
+ * TODO remove in v9*/
+#define lv_spinbox_set_pos lv_spinbox_set_cursor_pos
+
+#endif /*LV_USE_SPINBOX*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+#endif /*LV_SPINBOX_H*/

include/liblvgl/extra/widgets/spinner/lv_spinner.h

@@ -0,0 +1,50 @@
+/**
+ * @file lv_spinner.h
+ *
+ */
+
+#ifndef LV_SPINNER_H
+#define LV_SPINNER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_SPINNER
+
+/*Testing of dependencies*/
+#if LV_USE_ARC == 0
+#error "lv_spinner: lv_arc is required. Enable it in lv_conf.h (LV_USE_ARC  1) "
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+extern const lv_obj_class_t lv_spinner_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_spinner_create(lv_obj_t * parent, uint32_t time, uint32_t arc_length);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_SPINNER*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_SPINNER_H*/

include/liblvgl/extra/widgets/tabview/lv_tabview.h

@@ -0,0 +1,65 @@
+/**
+ * @file lv_templ.h
+ *
+ */
+
+#ifndef LV_TABVIEW_H
+#define LV_TABVIEW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+#if LV_USE_TABVIEW
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_obj_t obj;
+    char ** map;
+    uint16_t tab_cnt;
+    uint16_t tab_cur;
+    lv_dir_t tab_pos;
+} lv_tabview_t;
+
+extern const lv_obj_class_t lv_tabview_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+lv_obj_t * lv_tabview_create(lv_obj_t * parent, lv_dir_t tab_pos, lv_coord_t tab_size);
+
+lv_obj_t * lv_tabview_add_tab(lv_obj_t * tv, const char * name);
+
+void lv_tabview_rename_tab(lv_obj_t * obj, uint32_t tab_id, const char * new_name);
+
+lv_obj_t * lv_tabview_get_content(lv_obj_t * tv);
+
+lv_obj_t * lv_tabview_get_tab_btns(lv_obj_t * tv);
+
+void lv_tabview_set_act(lv_obj_t * obj, uint32_t id, lv_anim_enable_t anim_en);
+
+uint16_t lv_tabview_get_tab_act(lv_obj_t * tv);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_TABVIEW*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TABVIEW_H*/

include/liblvgl/extra/widgets/tileview/lv_tileview.h

@@ -0,0 +1,72 @@
+/**
+ * @file lv_tileview.h
+ *
+ */
+
+#ifndef LV_TILEVIEW_H
+#define LV_TILEVIEW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj.h"
+
+#if LV_USE_TILEVIEW
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * tile_act;
+} lv_tileview_t;
+
+typedef struct {
+    lv_obj_t obj;
+    lv_dir_t dir;
+} lv_tileview_tile_t;
+
+extern const lv_obj_class_t lv_tileview_class;
+extern const lv_obj_class_t lv_tileview_tile_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a Tileview object
+ * @param parent pointer to an object, it will be the parent of the new tileview
+ * @return pointer to the created tileview
+ */
+lv_obj_t * lv_tileview_create(lv_obj_t * parent);
+
+lv_obj_t * lv_tileview_add_tile(lv_obj_t * tv, uint8_t col_id, uint8_t row_id, lv_dir_t dir);
+
+void lv_obj_set_tile(lv_obj_t * tv, lv_obj_t * tile_obj, lv_anim_enable_t anim_en);
+void lv_obj_set_tile_id(lv_obj_t * tv, uint32_t col_id, uint32_t row_id, lv_anim_enable_t anim_en);
+
+lv_obj_t * lv_tileview_get_tile_act(lv_obj_t * obj);
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_TILEVIEW*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TILEVIEW_H*/

include/liblvgl/extra/widgets/win/lv_win.h

@@ -0,0 +1,51 @@
+/**
+ * @file lv_win.h
+ *
+ */
+
+#ifndef LV_WIN_H
+#define LV_WIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_obj_t obj;
+} lv_win_t;
+
+extern const lv_obj_class_t lv_win_class;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_obj_t * lv_win_create(lv_obj_t * parent, lv_coord_t header_height);
+
+
+lv_obj_t * lv_win_add_title(lv_obj_t * win, const char * txt);
+lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * icon, lv_coord_t btn_w);
+
+lv_obj_t * lv_win_get_header(lv_obj_t * win);
+lv_obj_t * lv_win_get_content(lv_obj_t * win);
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_WIN_H*/