Introducing Bootloader Development Kit (BDK)

BDK will allow developers to use the full collection of drivers,
with limited editing, if any, for making payloads for Nintendo Switch.

Using a single source for everything will also help decoupling
Switch specific code and easily port it to other Tegra X1/X1+ platforms.
And maybe even to lower targets.

Everything is now centrilized into bdk folder.
Every module or project can utilize it by simply including it.

This is just the start and it will continue to improve.

bdk/libs/lvgl/lv_misc/lv_anim.c

@@ -0,0 +1,445 @@
+/**
+ * @file anim.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_anim.h"
+
+#if USE_LV_ANIMATION
+#include <stddef.h>
+#include <string.h>
+#include "../lv_hal/lv_hal_tick.h"
+#include "lv_task.h"
+#include "lv_math.h"
+#include "lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#   include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_ANIM_RESOLUTION      1024
+#define LV_ANIM_RES_SHIFT       10
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void anim_task(void * param);
+static bool anim_ready_handler(lv_anim_t * a);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static uint32_t last_task_run;
+static bool anim_list_changed;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Init. the animation module
+ */
+void lv_anim_init(void)
+{
+    lv_ll_init(&LV_GC_ROOT(_lv_anim_ll), sizeof(lv_anim_t));
+    last_task_run = lv_tick_get();
+    lv_task_create(anim_task, LV_REFR_PERIOD, LV_TASK_PRIO_MID, NULL);
+}
+
+/**
+ * Create an animation
+ * @param anim_p an initialized 'anim_t' variable. Not required after call.
+ */
+void lv_anim_create(lv_anim_t * anim_p)
+{
+    LV_LOG_TRACE("animation create started")
+    /* Do not let two animations for the  same 'var' with the same 'fp'*/
+    if(anim_p->fp != NULL) lv_anim_del(anim_p->var, anim_p->fp);       /*fp == NULL would delete all animations of var*/
+
+    /*Add the new animation to the animation linked list*/
+    lv_anim_t * new_anim = lv_ll_ins_head(&LV_GC_ROOT(_lv_anim_ll));
+    lv_mem_assert(new_anim);
+    if(new_anim == NULL) return;
+
+    /*Initialize the animation descriptor*/
+    anim_p->playback_now = 0;
+    memcpy(new_anim, anim_p, sizeof(lv_anim_t));
+
+    /*Set the start value*/
+    if(new_anim->fp != NULL) new_anim->fp(new_anim->var, new_anim->start);
+
+    /* Creating an animation changed the linked list.
+     * It's important if it happens in a ready callback. (see `anim_task`)*/
+    anim_list_changed = true;
+
+    LV_LOG_TRACE("animation created")
+}
+
+/**
+ * Delete an animation for a variable with a given animator function
+ * @param var pointer to variable
+ * @param fp a function pointer which is animating 'var',
+ *           or NULL to delete all animations of 'var'
+ * @return true: at least 1 animation is deleted, false: no animation is deleted
+ */
+bool lv_anim_del(void * var, lv_anim_fp_t fp)
+{
+    lv_anim_t * a;
+    lv_anim_t * a_next;
+    bool del = false;
+    a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
+    while(a != NULL) {
+        /*'a' might be deleted, so get the next object while 'a' is valid*/
+        a_next = lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
+
+        if(a->var == var && (a->fp == fp || fp == NULL)) {
+            lv_ll_rem(&LV_GC_ROOT(_lv_anim_ll), a);
+            lv_mem_free(a);
+            anim_list_changed = true;       /*Read by `anim_task`. It need to know if a delete occurred in the linked list*/
+            del = true;
+        }
+
+        a = a_next;
+    }
+
+    return del;
+}
+
+/**
+ * Get the number of currently running animations
+ * @return the number of running animations
+ */
+uint16_t lv_anim_count_running(void)
+{
+    uint16_t cnt = 0;
+    lv_anim_t * a;
+    LL_READ(LV_GC_ROOT(_lv_anim_ll), a) cnt++;
+
+    return cnt++;
+}
+
+/**
+ * Calculate the time of an animation with a given speed and the start and end values
+ * @param speed speed of animation in unit/sec
+ * @param start start value of the animation
+ * @param end end value of the animation
+ * @return the required time [ms] for the animation with the given parameters
+ */
+uint16_t lv_anim_speed_to_time(uint16_t speed, int32_t start, int32_t end)
+{
+    int32_t d = LV_MATH_ABS((int32_t) start - end);
+    uint32_t time = (int32_t)((int32_t)(d * 1000) / speed);
+
+    if(time > UINT16_MAX) time = UINT16_MAX;
+
+    if(time == 0) {
+        time++;
+    }
+
+    return time;
+}
+
+/**
+ * Calculate the current value of an animation applying linear characteristic
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_linear(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+    uint16_t step;
+    if(a->time == a->act_time) step = LV_ANIM_RESOLUTION; /*Use the last value if the time fully elapsed*/
+    else step = (a->act_time * LV_ANIM_RESOLUTION) / a->time;
+
+    /* Get the new value which will be proportional to `step`
+     * and the `start` and `end` values*/
+    int32_t new_value;
+    new_value = (int32_t) step * (a->end - a->start);
+    new_value = new_value >> LV_ANIM_RES_SHIFT;
+    new_value += a->start;
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation slowing down the start phase
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_in(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+    uint32_t t;
+    if(a->time == a->act_time) t = 1024;
+    else t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
+
+    int32_t step = lv_bezier3(t, 0, 1, 1, 1024);
+
+    int32_t new_value;
+    new_value = (int32_t) step * (a->end - a->start);
+    new_value = new_value >> 10;
+    new_value += a->start;
+
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation slowing down the end phase
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_out(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+
+    uint32_t t;
+    if(a->time == a->act_time) t = 1024;
+    else t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
+
+    int32_t step = lv_bezier3(t, 0, 1023, 1023, 1024);
+
+    int32_t new_value;
+    new_value = (int32_t) step * (a->end - a->start);
+    new_value = new_value >> 10;
+    new_value += a->start;
+
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation applying an "S" characteristic (cosine)
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_in_out(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+
+    uint32_t t;
+    if(a->time == a->act_time) t = 1024;
+    else t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
+
+    int32_t step = lv_bezier3(t, 0, 100, 924, 1024);
+
+    int32_t new_value;
+    new_value = (int32_t) step * (a->end - a->start);
+    new_value = new_value >> 10;
+    new_value += a->start;
+
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation with overshoot at the end
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_overshoot(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+
+    uint32_t t;
+    if(a->time == a->act_time) t = 1024;
+    else t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
+
+    int32_t step = lv_bezier3(t, 0, 600, 1300, 1024);
+
+    int32_t new_value;
+    new_value = (int32_t) step * (a->end - a->start);
+    new_value = new_value >> 10;
+    new_value += a->start;
+
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation with 3 bounces
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_bounce(const lv_anim_t * a)
+{
+    /*Calculate the current step*/
+    uint32_t t;
+    if(a->time == a->act_time) t = 1024;
+    else t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
+
+    int32_t diff = (a->end - a->start);
+
+    /*3 bounces has 5 parts: 3 down and 2 up. One part is t / 5 long*/
+
+    if(t < 408){
+        /*Go down*/
+        t = (t * 2500) >> 10;      /*[0..1024] range*/
+    }
+    else if(t >= 408 && t < 614) {
+        /*First bounce back*/
+        t -= 408;
+        t = t * 5;      /*to [0..1024] range*/
+        t = 1024 - t;
+        diff = diff / 6;
+    }
+    else if(t >= 614 && t < 819) {
+        /*Fall back*/
+        t -= 614;
+        t = t * 5;      /*to [0..1024] range*/
+        diff = diff / 6;
+    }
+    else if(t >= 819 && t < 921) {
+        /*Second bounce back*/
+        t -= 819;
+        t = t * 10;      /*to [0..1024] range*/
+        t = 1024 - t;
+        diff = diff / 16;
+    }
+    else if(t >= 921 && t <= 1024) {
+        /*Fall back*/
+        t -= 921;
+        t = t * 10;      /*to [0..1024] range*/
+        diff = diff / 16;
+    }
+
+    if(t > 1024) t = 1024;
+
+    int32_t step = lv_bezier3(t, 1024, 1024, 800, 0);
+
+    int32_t new_value;
+
+    new_value = (int32_t) step * diff;
+    new_value = new_value >> 10;
+    new_value = a->end - new_value;
+
+
+    return new_value;
+}
+
+/**
+ * Calculate the current value of an animation applying step characteristic.
+ * (Set end value on the end of the animation)
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_step(const lv_anim_t * a)
+{
+    if(a->act_time >= a->time) return a->end;
+    else return a->start;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Periodically handle the animations.
+ * @param param unused
+ */
+static void anim_task(void * param)
+{
+    (void)param;
+
+    lv_anim_t * a;
+    LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
+        a->has_run = 0;
+    }
+
+    uint32_t elaps = lv_tick_elaps(last_task_run);
+    a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
+
+    while(a != NULL) {
+        /*It can be set by `lv_anim_del()` typically in `end_cb`. If set then an animation delete happened in `anim_ready_handler`
+         * which could make this linked list reading corrupt because the list is changed meanwhile
+         */
+        anim_list_changed = false;
+
+        if(!a->has_run) {
+            a->has_run = 1;         /*The list readying might be reseted so need to know which anim has run already*/
+            a->act_time += elaps;
+            if(a->act_time >= 0) {
+                if(a->act_time > a->time) a->act_time = a->time;
+
+                int32_t new_value;
+                new_value = a->path(a);
+
+                if(a->fp != NULL) a->fp(a->var, new_value); /*Apply the calculated value*/
+
+                /*If the time is elapsed the animation is ready*/
+                if(a->act_time >= a->time) {
+                    anim_ready_handler(a);
+                }
+            }
+        }
+
+        /* If the linked list changed due to anim. delete then it's not safe to continue
+         * the reading of the list from here -> start from the head*/
+        if(anim_list_changed) a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
+        else a = lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
+    }
+
+    last_task_run = lv_tick_get();
+}
+
+/**
+ * Called when an animation is ready to do the necessary thinks
+ * e.g. repeat, play back, delete etc.
+ * @param a pointer to an animation descriptor
+ * @return true: animation delete occurred nnd the `LV_GC_ROOT(_lv_anim_ll)` has changed
+ * */
+static bool anim_ready_handler(lv_anim_t * a)
+{
+
+    /*Delete the animation if
+     * - no repeat and no play back (simple one shot animation)
+     * - no repeat, play back is enabled and play back is ready */
+    if((a->repeat == 0 && a->playback == 0) ||
+            (a->repeat == 0 && a->playback == 1 && a->playback_now == 1)) {
+        void (*cb)(void *) = a->end_cb;
+        void * p = a->var;
+        lv_ll_rem(&LV_GC_ROOT(_lv_anim_ll), a);
+        lv_mem_free(a);
+        anim_list_changed = true;
+
+        /* Call the callback function at the end*/
+        /* Check if an animation is deleted in the cb function
+         * if yes then the caller function has to know this*/
+        if(cb != NULL) cb(p);
+    }
+    /*If the animation is not deleted then restart it*/
+    else {
+        a->act_time = - a->repeat_pause;    /*Restart the animation*/
+        /*Swap the start and end values in play back mode*/
+        if(a->playback != 0) {
+            /*If now turning back use the 'playback_pause*/
+            if(a->playback_now == 0) a->act_time = - a->playback_pause;
+
+            /*Toggle the play back state*/
+            a->playback_now = a->playback_now == 0 ? 1 : 0;
+            /*Swap the start and end values*/
+            int32_t tmp;
+            tmp = a->start;
+            a->start = a->end;
+            a->end = tmp;
+        }
+    }
+
+    return anim_list_changed;
+}
+#endif

bdk/libs/lvgl/lv_misc/lv_anim.h

@@ -0,0 +1,176 @@
+/**
+ * @file anim.h
+ *
+ */
+
+#ifndef ANIM_H
+#define ANIM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#if USE_LV_ANIMATION
+
+#include <stdint.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_anim_t;
+
+typedef int32_t(*lv_anim_path_t)(const struct _lv_anim_t*);
+
+typedef void (*lv_anim_fp_t)(void *, int32_t);
+typedef void (*lv_anim_cb_t)(void *);
+
+typedef struct _lv_anim_t
+{
+    void * var;                     /*Variable to animate*/
+    lv_anim_fp_t fp;                /*Animator function*/
+    lv_anim_cb_t end_cb;            /*Call it when the animation is ready*/
+    lv_anim_path_t path;            /*An array with the steps of animations*/
+    int32_t start;                  /*Start value*/
+    int32_t end;                    /*End value*/
+    uint16_t time;                  /*Animation time in ms*/
+    int16_t act_time;               /*Current time in animation. Set to negative to make delay.*/
+    uint16_t playback_pause;        /*Wait before play back*/
+    uint16_t repeat_pause;          /*Wait before repeat*/
+    uint8_t playback :1;            /*When the animation is ready play it back*/
+    uint8_t repeat :1;              /*Repeat the animation infinitely*/
+    /*Animation system use these - user shouldn't set*/
+    uint8_t playback_now :1;        /*Play back is in progress*/
+    uint32_t has_run     :1;        /*Indicates the animation has run it this round*/
+} lv_anim_t;
+
+/*Example initialization
+lv_anim_t a;
+a.var = obj;
+a.start = lv_obj_get_height(obj);
+a.end = new_height;
+a.fp = (lv_anim_fp_t)lv_obj_set_height;
+a.path = lv_anim_path_linear;
+a.end_cb = NULL;
+a.act_time = 0;
+a.time = 200;
+a.playback = 0;
+a.playback_pause = 0;
+a.repeat = 0;
+a.repeat_pause = 0;
+lv_anim_create(&a);
+ */
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Init. the animation module
+ */
+void lv_anim_init(void);
+
+/**
+ * Create an animation
+ * @param anim_p an initialized 'anim_t' variable. Not required after call.
+ */
+void lv_anim_create(lv_anim_t * anim_p);
+
+/**
+ * Delete an animation for a variable with a given animatior function
+ * @param var pointer to variable
+ * @param fp a function pointer which is animating 'var',
+ *           or NULL to ignore it and delete all animation with 'var
+ * @return true: at least 1 animation is deleted, false: no animation is deleted
+ */
+bool lv_anim_del(void * var, lv_anim_fp_t fp);
+
+/**
+ * Get the number of currently running animations
+ * @return the number of running animations
+ */
+uint16_t lv_anim_count_running(void);
+
+/**
+ * Calculate the time of an animation with a given speed and the start and end values
+ * @param speed speed of animation in unit/sec
+ * @param start start value of the animation
+ * @param end end value of the animation
+ * @return the required time [ms] for the animation with the given parameters
+ */
+uint16_t lv_anim_speed_to_time(uint16_t speed, int32_t start, int32_t end);
+
+/**
+ * Calculate the current value of an animation applying linear characteristic
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_linear(const lv_anim_t *a);
+
+/**
+ * Calculate the current value of an animation slowing down the start phase
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_in(const lv_anim_t * a);
+
+/**
+ * Calculate the current value of an animation slowing down the end phase
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_out(const lv_anim_t * a);
+
+/**
+ * Calculate the current value of an animation applying an "S" characteristic (cosine)
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_ease_in_out(const lv_anim_t *a);
+
+/**
+ * Calculate the current value of an animation with overshoot at the end
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_overshoot(const lv_anim_t * a);
+
+/**
+ * Calculate the current value of an animation with 3 bounces
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_bounce(const lv_anim_t * a);
+
+/**
+ * Calculate the current value of an animation applying step characteristic.
+ * (Set end value on the end of the animation)
+ * @param a pointer to an animation
+ * @return the current value to set
+ */
+int32_t lv_anim_path_step(const lv_anim_t *a);
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*USE_LV_ANIMATION == 0*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_ANIM_H*/
+

bdk/libs/lvgl/lv_misc/lv_area.c

@@ -0,0 +1,200 @@
+/**
+ * @file lv_area.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_area.h"
+#include "lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize an area
+ * @param area_p pointer to an area
+ * @param x1 left coordinate of the area
+ * @param y1 top coordinate of the area
+ * @param x2 right coordinate of the area
+ * @param y2 bottom coordinate of the area
+ */
+void lv_area_set(lv_area_t * area_p, lv_coord_t x1, lv_coord_t y1, lv_coord_t x2, lv_coord_t y2)
+{
+    area_p->x1 = x1;
+    area_p->y1 = y1;
+    area_p->x2 = x2;
+    area_p->y2 = y2;
+}
+
+/**
+ * Set the width of an area
+ * @param area_p pointer to an area
+ * @param w the new width of the area (w == 1 makes x1 == x2)
+ */
+void lv_area_set_width(lv_area_t * area_p, lv_coord_t w)
+{
+    area_p->x2 = area_p->x1 + w - 1;
+}
+
+/**
+ * Set the height of an area
+ * @param area_p pointer to an area
+ * @param h the new height of the area (h == 1 makes y1 == y2)
+ */
+void lv_area_set_height(lv_area_t * area_p, lv_coord_t h)
+{
+    area_p->y2 = area_p->y1 + h - 1;
+}
+
+/**
+ * Set the position of an area (width and height will be kept)
+ * @param area_p pointer to an area
+ * @param x the new x coordinate of the area
+ * @param y the new y coordinate of the area
+ */
+void lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y)
+{
+    lv_coord_t w = lv_area_get_width(area_p);
+    lv_coord_t h = lv_area_get_height(area_p);
+    area_p->x1 = x;
+    area_p->y1 = y;
+    lv_area_set_width(area_p, w);
+    lv_area_set_height(area_p, h);
+}
+
+/**
+ * Return with area of an area (x * y)
+ * @param area_p pointer to an area
+ * @return size of area
+ */
+uint32_t lv_area_get_size(const lv_area_t * area_p)
+{
+    uint32_t size;
+
+    size = (uint32_t)(area_p->x2 - area_p->x1 + 1) *
+           (area_p->y2 - area_p->y1 + 1);
+
+    return size;
+}
+
+/**
+ * Get the common parts of two areas
+ * @param res_p pointer to an area, the result will be stored here
+ * @param a1_p pointer to the first area
+ * @param a2_p pointer to the second area
+ * @return false: the two area has NO common parts, res_p is invalid
+ */
+bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
+{
+    /* Get the smaller area from 'a1_p' and 'a2_p' */
+    res_p->x1 = LV_MATH_MAX(a1_p->x1, a2_p->x1);
+    res_p->y1 = LV_MATH_MAX(a1_p->y1, a2_p->y1);
+    res_p->x2 = LV_MATH_MIN(a1_p->x2, a2_p->x2);
+    res_p->y2 = LV_MATH_MIN(a1_p->y2, a2_p->y2);
+
+    /*If x1 or y1 greater then x2 or y2 then the areas union is empty*/
+    bool union_ok = true;
+    if((res_p->x1 > res_p->x2) ||
+            (res_p->y1 > res_p->y2)) {
+        union_ok = false;
+    }
+
+    return union_ok;
+}
+/**
+ * Join two areas into a third which involves the other two
+ * @param res_p pointer to an area, the result will be stored here
+ * @param a1_p pointer to the first area
+ * @param a2_p pointer to the second area
+ */
+void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
+{
+    a_res_p->x1 = LV_MATH_MIN(a1_p->x1, a2_p->x1);
+    a_res_p->y1 = LV_MATH_MIN(a1_p->y1, a2_p->y1);
+    a_res_p->x2 = LV_MATH_MAX(a1_p->x2, a2_p->x2);
+    a_res_p->y2 = LV_MATH_MAX(a1_p->y2, a2_p->y2);
+}
+
+/**
+ * Check if a point is on an area
+ * @param a_p pointer to an area
+ * @param p_p pointer to a point
+ * @return false:the point is out of the area
+ */
+bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p)
+{
+    bool is_on = false;
+
+    if((p_p->x >= a_p->x1 && p_p->x <= a_p->x2) &&
+            ((p_p->y >= a_p->y1 && p_p->y <= a_p->y2))) {
+        is_on = true;
+    }
+
+    return is_on;
+}
+
+/**
+ * Check if two area has common parts
+ * @param a1_p pointer to an area.
+ * @param a2_p pointer to an other area
+ * @return false: a1_p and a2_p has no common parts
+ */
+bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p)
+{
+    if((a1_p->x1 <= a2_p->x2) &&
+            (a1_p->x2 >= a2_p->x1) &&
+            (a1_p->y1 <= a2_p->y2) &&
+            (a1_p->y2 >= a2_p->y1)) {
+        return true;
+    } else {
+        return false;
+    }
+
+}
+
+/**
+ * Check if an area is fully on an other
+ * @param ain_p pointer to an area which could be in 'aholder_p'
+ * @param aholder pointer to an area which could involve 'ain_p'
+ * @return
+ */
+bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p)
+{
+    bool is_in = false;
+
+    if(ain_p->x1  >= aholder_p->x1 &&
+            ain_p->y1  >= aholder_p->y1 &&
+            ain_p->x2  <= aholder_p->x2 &&
+            ain_p->y2  <= aholder_p->y2) {
+        is_in = true;
+    }
+
+    return is_in;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

bdk/libs/lvgl/lv_misc/lv_area.h

@@ -0,0 +1,168 @@
+/**
+ * @file lv_area.h
+ *
+ */
+
+#ifndef LV_AREA_H
+#define LV_AREA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <string.h>
+#include "../../../utils/types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_COORD_MAX     (16383)    /*To avoid overflow don't let the max [-32,32k] range */
+#define LV_COORD_MIN     (-16384)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef int16_t lv_coord_t;
+
+typedef struct
+{
+    lv_coord_t x;
+    lv_coord_t y;
+} lv_point_t;
+
+typedef struct
+{
+    lv_coord_t x1;
+    lv_coord_t y1;
+    lv_coord_t x2;
+    lv_coord_t y2;
+} lv_area_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize an area
+ * @param area_p pointer to an area
+ * @param x1 left coordinate of the area
+ * @param y1 top coordinate of the area
+ * @param x2 right coordinate of the area
+ * @param y2 bottom coordinate of the area
+ */
+void lv_area_set(lv_area_t * area_p, lv_coord_t x1, lv_coord_t y1, lv_coord_t x2, lv_coord_t y2);
+
+/**
+ * Copy an area
+ * @param dest pointer to the destination area
+ * @param src pointer to the source area
+ */
+inline static void lv_area_copy(lv_area_t * dest, const lv_area_t * src)
+{
+    memcpy(dest, src, sizeof(lv_area_t));
+}
+
+/**
+ * Get the width of an area
+ * @param area_p pointer to an area
+ * @return the width of the area (if x1 == x2 -> width = 1)
+ */
+static inline lv_coord_t lv_area_get_width(const lv_area_t * area_p)
+{
+    return area_p->x2 - area_p->x1 + 1;
+}
+
+/**
+ * Get the height of an area
+ * @param area_p pointer to an area
+ * @return the height of the area (if y1 == y2 -> height = 1)
+ */
+static inline lv_coord_t lv_area_get_height(const lv_area_t * area_p)
+{
+    return area_p->y2 - area_p->y1 + 1;
+}
+
+/**
+ * Set the width of an area
+ * @param area_p pointer to an area
+ * @param w the new width of the area (w == 1 makes x1 == x2)
+ */
+void lv_area_set_width(lv_area_t * area_p, lv_coord_t w);
+
+/**
+ * Set the height of an area
+ * @param area_p pointer to an area
+ * @param h the new height of the area (h == 1 makes y1 == y2)
+ */
+void lv_area_set_height(lv_area_t * area_p, lv_coord_t h);
+
+/**
+ * Set the position of an area (width and height will be kept)
+ * @param area_p pointer to an area
+ * @param x the new x coordinate of the area
+ * @param y the new y coordinate of the area
+ */
+void lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Return with area of an area (x * y)
+ * @param area_p pointer to an area
+ * @return size of area
+ */
+uint32_t lv_area_get_size(const lv_area_t * area_p);
+
+/**
+ * Get the common parts of two areas
+ * @param res_p pointer to an area, the result will be stored her
+ * @param a1_p pointer to the first area
+ * @param a2_p pointer to the second area
+ * @return false: the two area has NO common parts, res_p is invalid
+ */
+bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
+
+/**
+ * Join two areas into a third which involves the other two
+ * @param res_p pointer to an area, the result will be stored here
+ * @param a1_p pointer to the first area
+ * @param a2_p pointer to the second area
+ */
+void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
+
+/**
+ * Check if a point is on an area
+ * @param a_p pointer to an area
+ * @param p_p pointer to a point
+ * @return false:the point is out of the area
+ */
+bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p);
+
+/**
+ * Check if two area has common parts
+ * @param a1_p pointer to an area.
+ * @param a2_p pointer to an other area
+ * @return false: a1_p and a2_p has no common parts
+ */
+bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p);
+
+/**
+ * Check if an area is fully on an other
+ * @param ain_p pointer to an area which could be on aholder_p
+ * @param aholder pointer to an area which could involve ain_p
+ * @return
+ */
+bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif

bdk/libs/lvgl/lv_misc/lv_circ.c

@@ -0,0 +1,79 @@
+/**
+ * @file lv_circ.c
+ * Circle drawing algorithm (with Bresenham)
+ * Only a 1/8 circle is calculated. Use CIRC_OCT1_X, CIRC_OCT1_Y macros to get
+ * the other octets.
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_circ.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the circle drawing
+ * @param c pointer to a point. The coordinates will be calculated here
+ * @param tmp point to a variable. It will store temporary data
+ * @param radius radius of the circle
+ */
+void lv_circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius)
+{
+    c->x = radius;
+    c->y = 0;
+    *tmp = 1 - radius;
+}
+
+/**
+ * Test the circle drawing is ready or not
+ * @param c same as in circ_init
+ * @return true if the circle is not ready yet
+ */
+bool lv_circ_cont(lv_point_t * c)
+{
+    return c->y <= c->x ? true : false;
+}
+
+/**
+ * Get the next point from the circle
+ * @param c same as in circ_init. The next point stored here.
+ * @param tmp same as in circ_init.
+ */
+void lv_circ_next(lv_point_t * c, lv_coord_t * tmp)
+{
+    c->y++;
+
+    if(*tmp <= 0) {
+        (*tmp) += 2 * c->y + 1;   // Change in decision criterion for y -> y+1
+    } else {
+        c->x--;
+        (*tmp) += 2 * (c->y - c->x) + 1;   // Change for y -> y+1, x -> x-1
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

bdk/libs/lvgl/lv_misc/lv_circ.h

@@ -0,0 +1,80 @@
+/**
+ * @file lv_circ.h
+ *
+ */
+
+#ifndef LV_CIRC_H
+#define LV_CIRC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stddef.h>
+#include "lv_area.h"
+#include "../../../utils/types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_CIRC_OCT1_X(p) (p.x)
+#define LV_CIRC_OCT1_Y(p) (p.y)
+#define LV_CIRC_OCT2_X(p) (p.y)
+#define LV_CIRC_OCT2_Y(p) (p.x)
+#define LV_CIRC_OCT3_X(p) (-p.y)
+#define LV_CIRC_OCT3_Y(p) (p.x)
+#define LV_CIRC_OCT4_X(p) (-p.x)
+#define LV_CIRC_OCT4_Y(p) (p.y)
+#define LV_CIRC_OCT5_X(p) (-p.x)
+#define LV_CIRC_OCT5_Y(p) (-p.y)
+#define LV_CIRC_OCT6_X(p) (-p.y)
+#define LV_CIRC_OCT6_Y(p) (-p.x)
+#define LV_CIRC_OCT7_X(p) (p.y)
+#define LV_CIRC_OCT7_Y(p) (-p.x)
+#define LV_CIRC_OCT8_X(p) (p.x)
+#define LV_CIRC_OCT8_Y(p) (-p.y)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the circle drawing
+ * @param c pointer to a point. The coordinates will be calculated here
+ * @param tmp point to a variable. It will store temporary data
+ * @param radius radius of the circle
+ */
+void lv_circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius);
+
+/**
+ * Test the circle drawing is ready or not
+ * @param c same as in circ_init
+ * @return true if the circle is not ready yet
+ */
+bool lv_circ_cont(lv_point_t * c);
+
+/**
+ * Get the next point from the circle
+ * @param c same as in circ_init. The next point stored here.
+ * @param tmp same as in circ_init.
+ */
+void lv_circ_next(lv_point_t * c, lv_coord_t * tmp);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif

bdk/libs/lvgl/lv_misc/lv_color.c

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2019-2020 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * @file lv_color.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define HUE_DEGREE 512
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Convert a HSV color to RGB
+ * @param h hue [0..359]
+ * @param s saturation [0..100]
+ * @param v value [0..100]
+ * @return the given RGB color in RGB (with LV_COLOR_DEPTH depth)
+ */
+lv_color_t lv_color_hsv_to_rgb(uint16_t hue, uint8_t sat, uint8_t val)
+{
+    uint8_t r, g, b;
+
+    uint32_t h = (hue * 360 * HUE_DEGREE -1) / 360;
+    uint32_t s = sat * 255 / 100;
+    uint32_t v = val * 255 / 100;
+    uint32_t p = (256 * v - s * v) / 256;
+    uint32_t region = h / (60 * 512);
+    
+    if(sat == 0)
+        return LV_COLOR_MAKE(v, v, v);
+
+    if (region & 1)
+    {
+        uint32_t q = (256 * 60 * HUE_DEGREE * v - h * s * v + 60 * HUE_DEGREE * s * v * region) /
+            (256 * 60 * HUE_DEGREE);
+
+        switch (region)
+        {
+        case 1:
+            r = q;
+            g = v;
+            b = p;
+            break;
+        case 3:
+            r = p;
+            g = q;
+            b = v;
+            break;
+        case 5:
+        default:
+            r = v;
+            g = p;
+            b = q;
+            break;
+        }
+    }
+    else
+    {
+        uint32_t t = (256 * 60 * HUE_DEGREE * v + h * s * v - 60 * HUE_DEGREE * s * v * (region + 1)) /
+            (256 * 60 * HUE_DEGREE);
+
+        switch (region)
+        {
+        case 0:
+            r = v;
+            g = t;
+            b = p;
+            break;
+        case 2:
+            r = p;
+            g = v;
+            b = t;
+            break;
+        case 4:
+        default:
+            r = t;
+            g = p;
+            b = v;
+            break;
+        }
+    }
+
+    return LV_COLOR_MAKE(r, g, b);
+}
+
+/**
+ * Convert an RGB color to HSV
+ * @param r red
+ * @param g green
+ * @param b blue
+ * @return the given RGB color n HSV
+ */
+lv_color_hsv_t lv_color_rgb_to_hsv(uint8_t r, uint8_t g, uint8_t b)
+{
+    lv_color_hsv_t hsv;
+    uint8_t rgbMin, rgbMax;
+
+    rgbMin = r < g ? (r < b ? r : b) : (g < b ? g : b);
+    rgbMax = r > g ? (r > b ? r : b) : (g > b ? g : b);
+
+    hsv.v = rgbMax;
+    if(hsv.v == 0) {
+        hsv.h = 0;
+        hsv.s = 0;
+        return hsv;
+    }
+
+    hsv.s = 255 * (long)(rgbMax - rgbMin) / hsv.v;
+    if(hsv.s == 0) {
+        hsv.h = 0;
+        return hsv;
+    }
+
+    if(rgbMax == r)
+        hsv.h = 0 + 43 * (g - b) / (rgbMax - rgbMin);
+    else if(rgbMax == g)
+        hsv.h = 85 + 43 * (b - r) / (rgbMax - rgbMin);
+    else
+        hsv.h = 171 + 43 * (r - g) / (rgbMax - rgbMin);
+
+    return hsv;
+}

bdk/libs/lvgl/lv_misc/lv_color.h

@@ -0,0 +1,455 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * @file lv_color.h
+ *
+ */
+
+#ifndef LV_COLOR_H
+#define LV_COLOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+/*Error checking*/
+#if LV_COLOR_DEPTH == 24
+#error "LV_COLOR_DEPTH  24 is deprecated. Use LV_COLOR_DEPTH  32 instead (lv_conf.h)"
+#endif
+
+#if LV_COLOR_DEPTH != 32 && LV_COLOR_SCREEN_TRANSP != 0
+#error "LV_COLOR_SCREEN_TRANSP requires LV_COLOR_DEPTH == 32. Set it in lv_conf.h"
+#endif
+
+#if LV_COLOR_DEPTH != 16 && LV_COLOR_16_SWAP != 0
+#error "LV_COLOR_16_SWAP requires LV_COLOR_DEPTH == 16. Set it in lv_conf.h"
+#endif
+
+
+#include <stdint.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_COLOR_WHITE   LV_COLOR_MAKE(0xFF,0xFF,0xFF)
+#define LV_COLOR_SILVER  LV_COLOR_MAKE(0xC0,0xC0,0xC0)
+#define LV_COLOR_GRAY    LV_COLOR_MAKE(0x80,0x80,0x80)
+#define LV_COLOR_BLACK   LV_COLOR_MAKE(0x00,0x00,0x00)
+#define LV_COLOR_RED     LV_COLOR_MAKE(0xFF,0x00,0x00)
+#define LV_COLOR_MAROON  LV_COLOR_MAKE(0x80,0x00,0x00)
+#define LV_COLOR_YELLOW  LV_COLOR_MAKE(0xFF,0xFF,0x00)
+#define LV_COLOR_OLIVE   LV_COLOR_MAKE(0x80,0x80,0x00)
+#define LV_COLOR_LIME    LV_COLOR_MAKE(0x00,0xFF,0x00)
+#define LV_COLOR_GREEN   LV_COLOR_MAKE(0x00,0x80,0x00)
+#define LV_COLOR_CYAN    LV_COLOR_MAKE(0x00,0xFF,0xFF)
+#define LV_COLOR_AQUA    LV_COLOR_CYAN
+#define LV_COLOR_TEAL    LV_COLOR_MAKE(0x00,0x80,0x80)
+#define LV_COLOR_BLUE    LV_COLOR_MAKE(0x00,0x00,0xFF)
+#define LV_COLOR_NAVY    LV_COLOR_MAKE(0x00,0x00,0x80)
+#define LV_COLOR_MAGENTA LV_COLOR_MAKE(0xFF,0x00,0xFF)
+#define LV_COLOR_PURPLE  LV_COLOR_MAKE(0x80,0x00,0x80)
+#define LV_COLOR_ORANGE  LV_COLOR_MAKE(0xFF,0xA5,0x00)
+
+enum {
+    LV_OPA_TRANSP =  0,
+    LV_OPA_0      =  0,
+    LV_OPA_10     =  25,
+    LV_OPA_20     =  51,
+    LV_OPA_30     =  76,
+    LV_OPA_40     =  102,
+    LV_OPA_50     =  127,
+    LV_OPA_60     =  153,
+    LV_OPA_70     =  178,
+    LV_OPA_80     =  204,
+    LV_OPA_90     =  229,
+    LV_OPA_100    =  255,
+    LV_OPA_COVER  =  255,
+};
+
+#define LV_OPA_MIN      16      /*Opacities below this will be transparent*/
+#define LV_OPA_MAX      251     /*Opacities above this will fully cover*/
+
+#if LV_COLOR_DEPTH == 1
+#define LV_COLOR_SIZE           8
+#elif LV_COLOR_DEPTH == 8
+#define LV_COLOR_SIZE           8
+#elif LV_COLOR_DEPTH == 16
+#define LV_COLOR_SIZE           16
+#elif LV_COLOR_DEPTH == 32
+#define LV_COLOR_SIZE           32
+#else
+#error "Invalid LV_COLOR_DEPTH in lv_conf.h! Set it to 1, 8, 16 or 32!"
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef union
+{
+    uint8_t blue  :1;
+    uint8_t green :1;
+    uint8_t red   :1;
+    uint8_t full  :1;
+} lv_color1_t;
+
+typedef union
+{
+    struct
+    {
+        uint8_t blue  :2;
+        uint8_t green :3;
+        uint8_t red   :3;
+    };
+    uint8_t full;
+} lv_color8_t;
+
+typedef union
+{
+    struct
+    {
+#if LV_COLOR_16_SWAP == 0
+        uint16_t blue  :5;
+        uint16_t green :6;
+        uint16_t red   :5;
+#else
+        uint16_t green_h :3;
+        uint16_t red   :5;
+        uint16_t blue  :5;
+        uint16_t green_l :3;
+#endif
+    };
+    uint16_t full;
+} lv_color16_t;
+
+typedef union
+{
+    struct
+    {
+        uint8_t blue;
+        uint8_t green;
+        uint8_t red;
+        uint8_t alpha;
+    };
+    uint32_t full;
+} lv_color32_t;
+
+#if LV_COLOR_DEPTH == 1
+typedef uint8_t lv_color_int_t;
+typedef lv_color1_t lv_color_t;
+#elif LV_COLOR_DEPTH == 8
+typedef uint8_t lv_color_int_t;
+typedef lv_color8_t lv_color_t;
+#elif LV_COLOR_DEPTH == 16
+typedef uint16_t lv_color_int_t;
+typedef lv_color16_t lv_color_t;
+#elif LV_COLOR_DEPTH == 32
+typedef uint32_t lv_color_int_t;
+typedef lv_color32_t lv_color_t;
+#else
+#error "Invalid LV_COLOR_DEPTH in lv_conf.h! Set it to 1, 8, 16 or 32!"
+#endif
+
+typedef uint8_t lv_opa_t;
+
+typedef struct
+{
+    uint16_t h;
+    uint8_t s;
+    uint8_t v;
+} lv_color_hsv_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*In color conversations:
+ * - When converting to bigger color type the LSB weight of 1 LSB is calculated
+ *   E.g. 16 bit Red has 5 bits
+ *         8 bit Red has 2 bits
+ *        ----------------------
+ *        8 bit red LSB = (2^5 - 1) / (2^2 - 1) = 31 / 3 = 10
+ *
+ * - When calculating to smaller color type simply shift out the LSBs
+ *   E.g.  8 bit Red has 2 bits
+ *        16 bit Red has 5 bits
+ *        ----------------------
+ *         Shift right with 5 - 3 = 2
+ */
+
+static inline uint8_t lv_color_to1(lv_color_t color)
+{
+#if LV_COLOR_DEPTH == 1
+    return color.full;
+#elif LV_COLOR_DEPTH == 8
+    if((color.red   & 0x4) ||
+            (color.green & 0x4) ||
+            (color.blue  & 0x2)) {
+        return 1;
+    } else {
+        return 0;
+    }
+#elif LV_COLOR_DEPTH == 16
+#  if LV_COLOR_16_SWAP == 0
+    if((color.red   & 0x10) ||
+            (color.green & 0x20) ||
+            (color.blue  & 0x10)) {
+        return 1;
+#  else
+    if((color.red   & 0x10) ||
+            (color.green_h & 0x20) ||
+            (color.blue  & 0x10)) {
+        return 1;
+#  endif
+    } else {
+        return 0;
+    }
+#elif LV_COLOR_DEPTH == 32
+    if((color.red   & 0x80) ||
+            (color.green & 0x80) ||
+            (color.blue  & 0x80)) {
+        return 1;
+    } else {
+        return 0;
+    }
+#endif
+}
+
+static inline uint8_t lv_color_to8(lv_color_t color)
+{
+#if LV_COLOR_DEPTH == 1
+    if(color.full == 0) return 0;
+    else return 0xFF;
+#elif LV_COLOR_DEPTH == 8
+    return color.full;
+#elif LV_COLOR_DEPTH == 16
+
+#  if LV_COLOR_16_SWAP == 0
+    lv_color8_t ret;
+    ret.red = color.red >> 2;       /* 5 - 3  = 2*/
+    ret.green = color.green >> 3;   /* 6 - 3  = 3*/
+    ret.blue = color.blue >> 3;     /* 5 - 2  = 3*/
+    return ret.full;
+#  else
+    lv_color8_t ret;
+    ret.red = color.red >> 2;       /* 5 - 3  = 2*/
+    ret.green = color.green_h;      /* 6 - 3  = 3*/
+    ret.blue = color.blue >> 3;     /* 5 - 2  = 3*/
+    return ret.full;
+#  endif
+#elif LV_COLOR_DEPTH == 32
+    lv_color8_t ret;
+    ret.red = color.red >> 5;       /* 8 - 3  = 5*/
+    ret.green = color.green >> 5;   /* 8 - 3  = 5*/
+    ret.blue = color.blue >> 6;     /* 8 - 2  = 6*/
+    return ret.full;
+#endif
+}
+
+static inline uint16_t lv_color_to16(lv_color_t color)
+{
+#if LV_COLOR_DEPTH == 1
+    if(color.full == 0) return 0;
+    else return 0xFFFF;
+#elif LV_COLOR_DEPTH == 8
+    lv_color16_t ret;
+#  if LV_COLOR_16_SWAP == 0
+    ret.red = color.red * 4;       /*(2^5 - 1)/(2^3 - 1) = 31/7 = 4*/
+    ret.green = color.green * 9;   /*(2^6 - 1)/(2^3 - 1) = 63/7 = 9*/
+    ret.blue = color.blue * 10;    /*(2^5 - 1)/(2^2 - 1) = 31/3 = 10*/
+#  else
+    ret.red = color.red * 4;
+    uint8_t g_tmp = color.green * 9;
+    ret.green_h = (g_tmp & 0x1F) >> 3;
+    ret.green_l = g_tmp & 0x07;
+    ret.blue = color.blue * 10;
+#  endif
+    return ret.full;
+#elif LV_COLOR_DEPTH == 16
+    return color.full;
+#elif LV_COLOR_DEPTH == 32
+    lv_color16_t ret;
+#  if LV_COLOR_16_SWAP == 0
+    ret.red = color.red >> 3;       /* 8 - 5  = 3*/
+    ret.green = color.green >> 2;   /* 8 - 6  = 2*/
+    ret.blue = color.blue >> 3;     /* 8 - 5  = 3*/
+#  else
+    ret.red = color.red >> 3;
+    ret.green_h = (color.green & 0xE0) >> 5;
+    ret.green_l = (color.green & 0x1C) >> 2;
+    ret.blue = color.blue >> 3;
+#  endif
+    return ret.full;
+#endif
+}
+
+static inline uint32_t lv_color_to32(lv_color_t color)
+{
+#if LV_COLOR_DEPTH == 1
+    if(color.full == 0) return 0;
+    else return 0xFFFFFFFF;
+#elif LV_COLOR_DEPTH == 8
+    lv_color32_t ret;
+    ret.red = color.red * 36;        /*(2^8 - 1)/(2^3 - 1) = 255/7 = 36*/
+    ret.green = color.green * 36;    /*(2^8 - 1)/(2^3 - 1) = 255/7 = 36*/
+    ret.blue = color.blue * 85;      /*(2^8 - 1)/(2^2 - 1) = 255/3 = 85*/
+    ret.alpha = 0xFF;
+    return ret.full;
+#elif LV_COLOR_DEPTH == 16
+#  if LV_COLOR_16_SWAP == 0
+    lv_color32_t ret;
+    ret.red = color.red * 8;       /*(2^8 - 1)/(2^5 - 1) = 255/31 = 8*/
+    ret.green = color.green * 4;   /*(2^8 - 1)/(2^6 - 1) = 255/63 = 4*/
+    ret.blue = color.blue * 8;     /*(2^8 - 1)/(2^5 - 1) = 255/31 = 8*/
+    ret.alpha = 0xFF;
+    return ret.full;
+#  else
+    lv_color32_t ret;
+    ret.red = color.red * 8;                                    /*(2^8 - 1)/(2^5 - 1) = 255/31 = 8*/
+    ret.green = ((color.green_h << 3) + color.green_l) * 4;     /*(2^8 - 1)/(2^6 - 1) = 255/63 = 4*/
+    ret.blue = color.blue * 8;                                   /*(2^8 - 1)/(2^5 - 1) = 255/31 = 8*/
+    ret.alpha = 0xFF;
+    return ret.full;
+#  endif
+#elif LV_COLOR_DEPTH == 32
+    return color.full;
+#endif
+}
+
+static inline lv_color_t lv_color_mix(const lv_color_t c1, const lv_color_t c2, uint8_t mix)
+{
+    lv_color_t ret;
+#if LV_COLOR_DEPTH != 1 && LV_COLOR_DEPTH != 32
+    /*LV_COLOR_DEPTH == 8, 16 or 32*/
+    ret.red =   (uint16_t)((uint16_t) c1.red * mix + (c2.red * (255 - mix))) >> 8;
+#  if LV_COLOR_DEPTH == 16 && LV_COLOR_16_SWAP
+    /*If swapped Green is in 2 parts*/
+    uint16_t g_1 = (c1.green_h << 3) + c1.green_l;
+    uint16_t g_2 = (c2.green_h << 3) + c2.green_l;
+    uint16_t g_out = (uint16_t)((uint16_t) g_1 * mix + (g_2 * (255 - mix))) >> 8;
+    ret.green_h = g_out >> 3;
+    ret.green_l = g_out & 0x7;
+#  else
+    ret.green = (uint16_t)((uint16_t) c1.green * mix + (c2.green * (255 - mix))) >> 8;
+#  endif
+    ret.blue =  (uint16_t)((uint16_t) c1.blue * mix + (c2.blue * (255 - mix))) >> 8;
+#else
+#   if LV_COLOR_DEPTH == 32
+    uint32_t rb = (((c1.full & 0x00FF00FF) * mix) + ((c2.full & 0x00FF00FF) * (255 - mix))) >> 8;
+    uint32_t g = (((((c1.full & 0x0000FF00) >> 8) * mix) + (((c2.full & 0x0000FF00) >> 8) * (255 - mix))) >> 8) << 8;
+    ret.full = 0xFF000000 | (0x00FF00FF & rb) | (0x0000FF00 & g);
+#   else
+    /*LV_COLOR_DEPTH == 1*/
+    ret.full = mix > LV_OPA_50 ? c1.full : c2.full;
+#   endif
+#endif
+
+    return ret;
+}
+
+/**
+ * Get the brightness of a color
+ * @param color a color
+ * @return the brightness [0..255]
+ */
+static inline uint8_t lv_color_brightness(lv_color_t color)
+{
+    lv_color32_t c32;
+    c32.full = lv_color_to32(color);
+    uint16_t bright = 3 * c32.red + c32.blue + 4 * c32.green;
+    return (uint16_t) bright >> 3;
+}
+
+/* The most simple macro to create a color from R,G and B values
+ * The order of bit field is different on Big-endian and Little-endian machines*/
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#if LV_COLOR_DEPTH == 1
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){(b8 >> 7 | g8 >> 7 | r8 >> 7)})
+#elif LV_COLOR_DEPTH == 8
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8 >> 6, g8 >> 5, r8 >> 5}})
+#elif LV_COLOR_DEPTH == 16
+#  if LV_COLOR_16_SWAP == 0
+#    define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8 >> 3, g8 >> 2, r8 >> 3}})
+#  else
+#    define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{g8 >> 5, r8 >> 3, b8 >> 3, (g8 >> 2) & 0x7}})
+#  endif
+#elif LV_COLOR_DEPTH == 32
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8, g8, r8, 0xff}})            /*Fix 0xff alpha*/
+#endif
+#else
+#if LV_COLOR_DEPTH == 1
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){(r8 >> 7 | g8 >> 7 | b8 >> 7)})
+#elif LV_COLOR_DEPTH == 8
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{r8 >> 6, g8 >> 5, b8 >> 5}})
+#elif LV_COLOR_DEPTH == 16
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{r8 >> 3, g8 >> 2, b8 >> 3}})
+#elif LV_COLOR_DEPTH == 32
+#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{0xff, r8, g8, b8}})            /*Fix 0xff alpha*/
+#endif
+#endif
+
+#if LV_COLOR_DEPTH == 32 // Concatenate into one 32-bit set. 
+#define LV_COLOR_HEX(c) ((lv_color_t){.full = (c | 0xFF000000)})
+#else
+#define LV_COLOR_HEX(c) LV_COLOR_MAKE(((uint32_t)((uint32_t)c >> 16) & 0xFF), \
+                                ((uint32_t)((uint32_t)c >> 8) & 0xFF), \
+                                ((uint32_t) c & 0xFF))
+#endif
+
+/*Usage LV_COLOR_HEX3(0x16C) which means LV_COLOR_HEX(0x1166CC)*/
+#define LV_COLOR_HEX3(c) LV_COLOR_MAKE((((c >> 4) & 0xF0) | ((c >> 8) & 0xF)),   \
+                                ((uint32_t)(c & 0xF0)       | ((c & 0xF0) >> 4)), \
+                                ((uint32_t)(c & 0xF)         | ((c & 0xF) << 4)))
+
+
+/**
+ * Convert a HSV color to RGB
+ * @param h hue [0..359]
+ * @param s saturation [0..100]
+ * @param v value [0..100]
+ * @return the given RGB color in RGB (with LV_COLOR_DEPTH depth)
+ */
+lv_color_t lv_color_hsv_to_rgb(uint16_t hue, uint8_t sat, uint8_t val);
+
+/**
+ * Convert an RGB color to HSV
+ * @param r red
+ * @param g green
+ * @param b blue
+ * @return the given RGB color n HSV
+ */
+lv_color_hsv_t lv_color_rgb_to_hsv(uint8_t r, uint8_t g, uint8_t b);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*USE_COLOR*/

bdk/libs/lvgl/lv_misc/lv_font.c

@@ -0,0 +1,269 @@
+/**
+ * @file lv_font.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stddef.h>
+#include "lv_font.h"
+#include "lv_log.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the fonts
+ */
+void lv_font_init(void)
+{
+    lv_font_builtin_init();
+}
+
+/**
+ * Add a font to an other to extend the character set.
+ * @param child the font to add
+ * @param parent this font will be extended. Using it later will contain the characters from `child`
+ */
+void lv_font_add(lv_font_t * child, lv_font_t * parent)
+{
+    if(parent == NULL) return;
+
+    while(parent->next_page != NULL) {
+        parent = parent->next_page; /*Got to the last page and add the new font there*/
+    }
+
+    parent->next_page = child;
+
+}
+
+/**
+ * Remove a font from a character set.
+ * @param child the font to remove
+ * @param parent remove `child` from here
+ */
+void lv_font_remove(lv_font_t * child, lv_font_t * parent)
+{
+    if(parent == NULL) return;
+    if(child == NULL) return;
+
+    while(parent->next_page != child) {
+        parent = parent->next_page; /*Got to the last page and add the new font there*/
+    }
+
+    parent->next_page = child->next_page;
+}
+
+
+/**
+ * Tells if font which contains `letter` is monospace or not
+ * @param font_p point to font
+ * @param letter an UNICODE character code
+ * @return true: the letter is monospace; false not monospace
+ */
+bool lv_font_is_monospace(const lv_font_t * font_p, uint32_t letter)
+{
+    const lv_font_t * font_i = font_p;
+    int16_t w;
+    while(font_i != NULL) {
+        w = font_i->get_width(font_i, letter);
+        if(w >= 0) {
+            /*Glyph found*/
+            if(font_i->monospace) return true;
+            return false;
+        }
+
+        font_i = font_i->next_page;
+    }
+
+    return 0;
+}
+
+/**
+ * Return with the bitmap of a font.
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return  pointer to the bitmap of the letter
+ */
+const uint8_t * lv_font_get_bitmap(const lv_font_t * font_p, uint32_t letter)
+{
+    const lv_font_t * font_i = font_p;
+    while(font_i != NULL) {
+        const uint8_t * bitmap = font_i->get_bitmap(font_i, letter);
+        if(bitmap) return bitmap;
+
+        font_i = font_i->next_page;
+    }
+
+    return NULL;
+}
+
+/**
+ * Get the width of a letter in a font. If `monospace` is set then return with it.
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return the width of a letter
+ */
+uint8_t lv_font_get_width(const lv_font_t * font_p, uint32_t letter)
+{
+    const lv_font_t * font_i = font_p;
+    int16_t w;
+    while(font_i != NULL) {
+        w = font_i->get_width(font_i, letter);
+        if(w >= 0) {
+            /*Glyph found*/
+            uint8_t m = font_i->monospace;
+            if(m) w = m;
+            return w;
+        }
+
+        font_i = font_i->next_page;
+    }
+
+    return 0;
+
+}
+
+/**
+ * Get the width of the letter without overwriting it with the `monospace` attribute
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return the width of a letter
+ */
+uint8_t lv_font_get_real_width(const lv_font_t * font_p, uint32_t letter)
+{
+    const lv_font_t * font_i = font_p;
+    int16_t w;
+    while(font_i != NULL) {
+        w = font_i->get_width(font_i, letter);
+        if(w >= 0) return w;
+
+        font_i = font_i->next_page;
+    }
+
+    return 0;
+}
+
+/**
+ * Get the bit-per-pixel of font
+ * @param font pointer to font
+ * @param letter a letter from font (font extensions can have different bpp)
+ * @return bpp of the font (or font extension)
+ */
+uint8_t lv_font_get_bpp(const lv_font_t * font, uint32_t letter)
+{
+    const lv_font_t * font_i = font;
+    while(font_i != NULL) {
+        if(letter >= font_i->unicode_first && letter <= font_i->unicode_last) {
+            return font_i->bpp;
+        }
+        font_i = font_i->next_page;
+    }
+
+    return 0;
+
+}
+
+/**
+ * Generic bitmap get function used in 'font->get_bitmap' when the font contains all characters in the range
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which bitmap should be get
+ * @return pointer to the bitmap or NULL if not found
+ */
+const uint8_t * lv_font_get_bitmap_continuous(const lv_font_t * font, uint32_t unicode_letter)
+{
+    /*Check the range*/
+    if(unicode_letter < font->unicode_first || unicode_letter > font->unicode_last) return NULL;
+
+    uint32_t index = (unicode_letter - font->unicode_first);
+    return &font->glyph_bitmap[font->glyph_dsc[index].glyph_index];
+}
+
+/**
+ * Generic bitmap get function used in 'font->get_bitmap' when the font NOT contains all characters in the range (sparse)
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which bitmap should be get
+ * @return pointer to the bitmap or NULL if not found
+ */
+const uint8_t * lv_font_get_bitmap_sparse(const lv_font_t * font, uint32_t unicode_letter)
+{
+    /*Check the range*/
+    if(unicode_letter < font->unicode_first || unicode_letter > font->unicode_last) return NULL;
+
+    uint32_t i;
+    for(i = 0; font->unicode_list[i] != 0; i++) {
+        if(font->unicode_list[i] == unicode_letter) {
+            return &font->glyph_bitmap[font->glyph_dsc[i].glyph_index];
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Generic glyph width get function used in 'font->get_width' when the font contains all characters in the range
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which width should be get
+ * @return width of the gylph or -1 if not found
+ */
+int16_t lv_font_get_width_continuous(const lv_font_t * font, uint32_t unicode_letter)
+{
+    /*Check the range*/
+    if(unicode_letter < font->unicode_first || unicode_letter > font->unicode_last) {
+        return -1;
+    }
+
+    uint32_t index = (unicode_letter - font->unicode_first);
+    return font->glyph_dsc[index].w_px;
+}
+
+/**
+ * Generic glyph width get function used in 'font->get_bitmap' when the font NOT contains all characters in the range (sparse)
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which width should be get
+ * @return width of the glyph or -1 if not found
+ */
+int16_t lv_font_get_width_sparse(const lv_font_t * font, uint32_t unicode_letter)
+{
+    /*Check the range*/
+    if(unicode_letter < font->unicode_first || unicode_letter > font->unicode_last) return -1;
+
+    uint32_t i;
+    for(i = 0; font->unicode_list[i] != 0; i++) {
+        if(font->unicode_list[i] == unicode_letter) {
+            return font->glyph_dsc[i].w_px;
+        }
+    }
+
+    return -1;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

bdk/libs/lvgl/lv_misc/lv_font.h

@@ -0,0 +1,191 @@
+/**
+ * @file lv_font.h
+ *
+ */
+
+#ifndef LV_FONT_H
+#define LV_FONT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "lv_symbol_def.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct
+{
+    uint32_t w_px         :8;
+    uint32_t glyph_index  :24;
+} lv_font_glyph_dsc_t;
+
+typedef struct
+{
+    uint32_t unicode         :21;
+    uint32_t glyph_dsc_index :11;
+} lv_font_unicode_map_t;
+
+typedef struct _lv_font_struct
+{
+    uint32_t unicode_first;
+    uint32_t unicode_last;
+    const uint8_t * glyph_bitmap;
+    const lv_font_glyph_dsc_t * glyph_dsc;
+    const uint32_t * unicode_list;
+    const uint8_t * (*get_bitmap)(const struct _lv_font_struct *,uint32_t);     /*Get a glyph's  bitmap from a font*/
+    int16_t (*get_width)(const struct _lv_font_struct *,uint32_t);        /*Get a glyph's with with a given font*/
+    struct _lv_font_struct * next_page;    /*Pointer to a font extension*/
+    uint32_t h_px       :8;
+    uint32_t bpp        :4;                /*Bit per pixel: 1, 2 or 4*/
+    uint32_t monospace  :8;                /*Fix width (0: normal width)*/
+    uint16_t glyph_cnt;                    /*Number of glyphs (letters) in the font*/
+} lv_font_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the fonts
+ */
+void lv_font_init(void);
+
+/**
+ * Add a font to an other to extend the character set.
+ * @param child the font to add
+ * @param parent this font will be extended. Using it later will contain the characters from `child`
+ */
+void lv_font_add(lv_font_t *child, lv_font_t *parent);
+
+/**
+ * Remove a font from a character set.
+ * @param child the font to remove
+ * @param parent remove `child` from here
+ */
+void lv_font_remove(lv_font_t * child, lv_font_t * parent);
+
+/**
+ * Tells if font which contains `letter` is monospace or not
+ * @param font_p point to font
+ * @param letter an UNICODE character code
+ * @return true: the letter is monospace; false not monospace
+ */
+bool lv_font_is_monospace(const lv_font_t * font_p, uint32_t letter);
+
+/**
+ * Return with the bitmap of a font.
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return  pointer to the bitmap of the letter
+ */
+const uint8_t * lv_font_get_bitmap(const lv_font_t * font_p, uint32_t letter);
+
+/**
+ * Get the width of a letter in a font. If `monospace` is set then return with it.
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return the width of a letter
+ */
+uint8_t lv_font_get_width(const lv_font_t * font_p, uint32_t letter);
+
+
+/**
+ * Get the width of the letter without overwriting it with the `monospace` attribute
+ * @param font_p pointer to a font
+ * @param letter an UNICODE character code
+ * @return the width of a letter
+ */
+uint8_t lv_font_get_real_width(const lv_font_t * font_p, uint32_t letter);
+
+/**
+ * Get the height of a font
+ * @param font_p pointer to a font
+ * @return the height of a font
+ */
+static inline uint8_t lv_font_get_height(const lv_font_t * font_p)
+{
+    return font_p->h_px;
+}
+
+/**
+ * Get the bit-per-pixel of font
+ * @param font pointer to font
+ * @param letter a letter from font (font extensions can have different bpp)
+ * @return bpp of the font (or font extension)
+ */
+uint8_t lv_font_get_bpp(const lv_font_t * font, uint32_t letter);
+
+/**
+ * Generic bitmap get function used in 'font->get_bitmap' when the font contains all characters in the range
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which bitmap should be get
+ * @return pointer to the bitmap or NULL if not found
+ */
+const uint8_t * lv_font_get_bitmap_continuous(const lv_font_t * font, uint32_t unicode_letter);
+
+/**
+ * Generic bitmap get function used in 'font->get_bitmap' when the font NOT contains all characters in the range (sparse)
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which bitmap should be get
+ * @return pointer to the bitmap or NULL if not found
+ */
+const uint8_t * lv_font_get_bitmap_sparse(const lv_font_t * font, uint32_t unicode_letter);
+/**
+ * Generic glyph width get function used in 'font->get_width' when the font contains all characters in the range
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which width should be get
+ * @return width of the gylph or -1 if not found
+ */
+int16_t lv_font_get_width_continuous(const lv_font_t * font, uint32_t unicode_letter);
+
+/**
+ * Generic glyph width get function used in 'font->get_bitmap' when the font NOT contains all characters in the range (sparse)
+ * @param font pointer to font
+ * @param unicode_letter an unicode letter which width should be get
+ * @return width of the glyph or -1 if not found
+ */
+int16_t lv_font_get_width_sparse(const lv_font_t * font, uint32_t unicode_letter);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define LV_FONT_DECLARE(font_name) extern lv_font_t font_name;
+
+
+/**********************
+ * ADD BUILT IN FONTS
+ **********************/
+#include "../lv_fonts/lv_font_builtin.h"
+
+/*Declare the custom (user defined) fonts*/
+#ifdef LV_FONT_CUSTOM_DECLARE
+LV_FONT_CUSTOM_DECLARE
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*USE_FONT*/
+

bdk/libs/lvgl/lv_misc/lv_fs.c

@@ -0,0 +1,627 @@
+/**
+ * @file lv_fs.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_fs.h"
+#if USE_LV_FILESYSTEM
+
+#include "lv_ll.h"
+#include <string.h>
+#include "lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#   include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/* "free" is used as a function pointer (in lv_fs_drv_t).
+ * We must make sure "free" was not defined to a platform specific
+ * free function, otherwise compilation would fail.
+ */
+#ifdef free
+#undef free
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static const char * lv_fs_get_real_path(const char * path);
+static lv_fs_drv_t * lv_fs_get_drv(char letter);
+
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the File system interface
+ */
+void lv_fs_init(void)
+{
+    lv_ll_init(&LV_GC_ROOT(_lv_drv_ll), sizeof(lv_fs_drv_t));
+}
+
+/**
+ * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be returned.
+ * @param letter letter of the drive
+ * @return true: drive is ready; false: drive is not ready
+ */
+bool lv_fs_is_ready(char letter)
+{
+    lv_fs_drv_t * drv = lv_fs_get_drv(letter);
+
+    if(drv == NULL) return false;                      /*An unknown driver in not ready*/
+
+    if(drv->ready == NULL) return true;                /*Assume the driver is always ready if no handler provided*/
+
+    return drv->ready();
+}
+
+/**
+ * Open a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mode)
+{
+    file_p->drv = NULL;
+    file_p->file_d = NULL;
+
+    if(path == NULL) return LV_FS_RES_INV_PARAM;
+
+    char letter = path[0];
+
+    file_p->drv = lv_fs_get_drv(letter);
+
+    if(file_p->drv == NULL) {
+        file_p->file_d = NULL;
+        return LV_FS_RES_NOT_EX;
+    }
+
+    if(file_p->drv->ready != NULL) {
+        if(file_p->drv->ready() == false) {
+            file_p->drv = NULL;
+            file_p->file_d = NULL;
+            return LV_FS_RES_HW_ERR;
+        }
+    }
+
+    file_p->file_d = lv_mem_alloc(file_p->drv->file_size);
+    lv_mem_assert(file_p->file_d);
+    if(file_p->file_d == NULL) {
+        file_p->drv = NULL;
+        return LV_FS_RES_OUT_OF_MEM;  /* Out of memory */
+    }
+
+    if(file_p->drv->open == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    const char * real_path = lv_fs_get_real_path(path);
+    lv_fs_res_t res = file_p->drv->open(file_p->file_d, real_path, mode);
+
+    if(res != LV_FS_RES_OK) {
+        lv_mem_free(file_p->file_d);
+        file_p->file_d = NULL;
+        file_p->drv = NULL;
+    }
+
+    return res;
+}
+
+/**
+ * Close an already opened file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
+{
+    if(file_p->drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->close == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    lv_fs_res_t res = file_p->drv->close(file_p->file_d);
+
+    lv_mem_free(file_p->file_d);   /*Clean up*/
+    file_p->file_d = NULL;
+    file_p->drv = NULL;
+    file_p->file_d = NULL;
+
+    return res;
+}
+
+/**
+ * Delete a file
+ * @param path path of the file to delete
+ * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_remove(const char * path)
+{
+    if(path == NULL) return LV_FS_RES_INV_PARAM;
+    lv_fs_drv_t * drv = NULL;
+
+    char letter = path[0];
+
+    drv = lv_fs_get_drv(letter);
+    if(drv == NULL) return LV_FS_RES_NOT_EX;
+    if(drv->ready != NULL) {
+        if(drv->ready() == false) return LV_FS_RES_HW_ERR;
+    }
+
+    if(drv->remove == NULL) return LV_FS_RES_NOT_IMP;
+
+    const char * real_path = lv_fs_get_real_path(path);
+    lv_fs_res_t res = drv->remove(real_path);
+
+    return res;
+}
+
+/**
+ * Read from a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param buf pointer to a buffer where the read bytes are stored
+ * @param btr Bytes To Read
+ * @param br the number of real read bytes (Bytes Read). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_read(lv_fs_file_t * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    if(br != NULL) *br = 0;
+    if(file_p->drv == NULL) return LV_FS_RES_INV_PARAM;
+    if(file_p->drv->read == NULL) return LV_FS_RES_NOT_IMP;
+
+    uint32_t br_tmp = 0;
+    lv_fs_res_t res = file_p->drv->read(file_p->file_d, buf, btr, &br_tmp);
+    if(br != NULL) *br = br_tmp;
+
+    return res;
+}
+
+/**
+ * Write into a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_write(lv_fs_file_t * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    if(bw != NULL) *bw = 0;
+
+    if(file_p->drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->write == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    uint32_t bw_tmp = 0;
+    lv_fs_res_t res = file_p->drv->write(file_p->file_d, buf, btw, &bw_tmp);
+    if(bw != NULL)  *bw = bw_tmp;
+
+    return res;
+}
+
+/**
+ * Set the position of the 'cursor' (read write pointer) in a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param pos the new position expressed in bytes index (0: start of file)
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos)
+{
+    if(file_p->drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->seek == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    lv_fs_res_t res = file_p->drv->seek(file_p->file_d, pos);
+
+    return res;
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param pos_p pointer to store the position of the read write pointer
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t  * pos)
+{
+    if(file_p->drv == NULL) {
+        pos = 0;
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->tell == NULL) {
+        pos = 0;
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    lv_fs_res_t res = file_p->drv->tell(file_p->file_d, pos);
+
+    return res;
+}
+
+/**
+ * Truncate the file size to the current position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open )
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_trunc(lv_fs_file_t * file_p)
+{
+    if(file_p->drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->tell == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    lv_fs_res_t res = file_p->drv->trunc(file_p->file_d);
+
+    return res;
+}
+/**
+ * Give the size of a file bytes
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param size pointer to a variable to store the size
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_size(lv_fs_file_t * file_p, uint32_t * size)
+{
+    if(file_p->drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(file_p->drv->size == NULL) return LV_FS_RES_NOT_IMP;
+
+
+    if(size == NULL) return LV_FS_RES_INV_PARAM;
+
+    lv_fs_res_t res = file_p->drv->size(file_p->file_d, size);
+
+    return res;
+}
+
+/**
+ * Rename a file
+ * @param oldname path to the file
+ * @param newname path with the new name
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+lv_fs_res_t lv_fs_rename(const char * oldname, const char * newname)
+{
+    if(!oldname || !newname) return LV_FS_RES_INV_PARAM;
+
+    char letter = oldname[0];
+
+    lv_fs_drv_t * drv = lv_fs_get_drv(letter);
+
+    if(!drv) {
+        return LV_FS_RES_NOT_EX;
+    }
+
+    if(drv->ready != NULL) {
+        if(drv->ready() == false) {
+            return LV_FS_RES_HW_ERR;
+        }
+    }
+
+    if(drv->rename == NULL) return LV_FS_RES_NOT_IMP;
+
+    const char * old_real = lv_fs_get_real_path(oldname);
+    const char * new_real = lv_fs_get_real_path(newname);
+    lv_fs_res_t res = drv->rename(old_real, new_real);
+
+    return res;
+}
+
+
+/**
+ * Initialize a 'fs_read_dir_t' variable for directory reading
+ * @param rddir_p pointer to a 'fs_read_dir_t' variable
+ * @param path path to a directory
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
+{
+    if(path == NULL) return LV_FS_RES_INV_PARAM;
+
+    char letter = path[0];
+
+    rddir_p->drv = lv_fs_get_drv(letter);
+
+    if(rddir_p->drv == NULL) {
+        rddir_p->dir_d = NULL;
+        return LV_FS_RES_NOT_EX;
+    }
+
+    rddir_p->dir_d = lv_mem_alloc(rddir_p->drv->rddir_size);
+    lv_mem_assert(rddir_p->dir_d);
+    if(rddir_p->dir_d == NULL) {
+        rddir_p->dir_d = NULL;
+        return LV_FS_RES_OUT_OF_MEM;  /* Out of memory */
+    }
+
+    if(rddir_p->drv->dir_open == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    const char * real_path = lv_fs_get_real_path(path);
+    lv_fs_res_t res = rddir_p->drv->dir_open(rddir_p->dir_d, real_path);
+
+    return res;
+}
+
+/**
+ * Read the next filename form a directory.
+ * The name of the directories will begin with '/'
+ * @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn)
+{
+    if(rddir_p->drv == NULL || rddir_p->dir_d == NULL) {
+        fn[0] = '\0';
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    if(rddir_p->drv->dir_read == NULL) {
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    lv_fs_res_t res = rddir_p->drv->dir_read(rddir_p->dir_d, fn);
+
+    return res;
+}
+
+/**
+ * Close the directory reading
+ * @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p)
+{
+    if(rddir_p->drv == NULL || rddir_p->dir_d == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    lv_fs_res_t res;
+
+    if(rddir_p->drv->dir_close == NULL) {
+        res =  LV_FS_RES_NOT_IMP;
+    } else {
+        res = rddir_p->drv->dir_close(rddir_p->dir_d);
+    }
+
+    lv_mem_free(rddir_p->dir_d);   /*Clean up*/
+    rddir_p->dir_d = NULL;
+    rddir_p->drv = NULL;
+    rddir_p->dir_d = NULL;
+
+    return res;
+}
+
+/**
+ * Get the free and total size of a driver in kB
+ * @param letter the driver letter
+ * @param total_p pointer to store the total size [kB]
+ * @param free_p pointer to store the free size [kB]
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_free(char letter, uint32_t * total_p, uint32_t * free_p)
+{
+    lv_fs_drv_t * drv = lv_fs_get_drv(letter);
+
+    if(drv == NULL) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    lv_fs_res_t res;
+
+    if(drv->free == NULL) {
+        res =  LV_FS_RES_NOT_IMP;
+    } else {
+        uint32_t total_tmp = 0;
+        uint32_t free_tmp = 0;
+        res = drv->free(&total_tmp, &free_tmp);
+
+        if(total_p != NULL) *total_p = total_tmp;
+        if(free_p != NULL) *free_p = free_tmp;
+    }
+
+    return res;
+}
+
+/**
+ * Add a new drive
+ * @param drv_p pointer to an lv_fs_drv_t structure which is inited with the
+ * corresponding function pointers. The data will be copied so the variable can be local.
+ */
+void lv_fs_add_drv(lv_fs_drv_t * drv_p)
+{
+    /*Save the new driver*/
+    lv_fs_drv_t * new_drv;
+    new_drv =  lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
+    lv_mem_assert(new_drv);
+    if(new_drv == NULL) return;
+
+    memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
+}
+
+/**
+ * Fill a buffer with the letters of existing drivers
+ * @param buf buffer to store the letters ('\0' added after the last letter)
+ * @return the buffer
+ */
+char  * lv_fs_get_letters(char * buf)
+{
+    lv_fs_drv_t * drv;
+    uint8_t i = 0;
+
+    LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
+        buf[i] = drv->letter;
+        i++;
+    }
+
+    buf[i] = '\0';
+
+    return buf;
+}
+
+
+/**
+ * Return with the extension of the filename
+ * @param fn string with a filename
+ * @return pointer to the beginning extension or empty string if no extension
+ */
+const char * lv_fs_get_ext(const char * fn)
+{
+    uint16_t i;
+    for(i = strlen(fn); i > 0; i --) {
+        if(fn[i] == '.') {
+            return &fn[i + 1];
+        } else if(fn[i] == '/' || fn[i] == '\\') {
+            return "";  /*No extension if a '\' or '/' found*/
+        }
+    }
+
+    return ""; /*Empty string if no '.' in the file name. */
+}
+
+/**
+ * Step up one level
+ * @param path pointer to a file name
+ * @return the truncated file name
+ */
+char * lv_fs_up(char * path)
+{
+    uint16_t len = strlen(path);
+    if(len == 0) return path;
+
+    len --; /*Go before the trailing '\0'*/
+
+    /*Ignore trailing '/' or '\'*/
+    while(path[len] == '/' || path[len] == '\\') {
+        path[len] = '\0';
+        if(len > 0) len --;
+        else return path;
+    }
+
+    uint16_t i;
+    for(i = len; i > 0; i --) {
+        if(path[i] == '/' || path[i] == '\\') break;
+    }
+
+    if(i > 0) path[i] = '\0';
+
+    return path;
+}
+
+/**
+ * Get the last element of a path (e.g. U:/folder/file -> file)
+ * @param path a character sting with the path to search in
+ * @return pointer to the beginning of the last element in the path
+ */
+const char * lv_fs_get_last(const char * path)
+{
+    uint16_t len = strlen(path);
+    if(len == 0) return path;
+
+    len --; /*Go before the trailing '\0'*/
+
+    /*Ignore trailing '/' or '\'*/
+    while(path[len] == '/' || path[len] == '\\') {
+        if(len > 0) len --;
+        else return path;
+    }
+
+    uint16_t i;
+    for(i = len; i > 0; i --) {
+        if(path[i] == '/' || path[i] == '\\') break;
+    }
+
+    /*No '/' or '\' in the path so return with path itself*/
+    if(i == 0) return path;
+
+    return &path[i + 1];
+}
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Leave the driver letters and / or \ letters from beginning of the path
+ * @param path path string (E.g. S:/folder/file.txt)
+ * @return pointer to the beginning of the real path (E.g. folder/file.txt)
+ */
+static const char * lv_fs_get_real_path(const char * path)
+{
+    /* Example path: "S:/folder/file.txt"
+     * Leave the letter and the : / \ characters*/
+
+    path ++; /*Ignore the driver letter*/
+
+    while(*path != '\0') {
+        if(*path == ':' || *path == '\\' || *path == '/') {
+            path ++;
+        } else {
+            break;
+        }
+    }
+
+    return path;
+}
+
+/**
+ * Give a pointer to a driver from its letter
+ * @param letter the driver letter
+ * @return pointer to a driver or NULL if not found
+ */
+static lv_fs_drv_t * lv_fs_get_drv(char letter)
+{
+    lv_fs_drv_t * drv;
+
+    LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
+        if(drv->letter == letter) {
+            return drv;
+        }
+    }
+
+    return NULL;
+}
+
+#endif /*USE_LV_FILESYSTEM*/

bdk/libs/lvgl/lv_misc/lv_fs.h

@@ -0,0 +1,276 @@
+/**
+ * @file lv_fs.h
+ *
+ */
+
+#ifndef LV_FS_H
+#define LV_FS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#if USE_LV_FILESYSTEM
+
+#include <stdint.h>
+#include "lv_mem.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_FS_MAX_FN_LENGTH  64
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum
+{
+    LV_FS_RES_OK = 0,
+    LV_FS_RES_HW_ERR,      /*Low level hardware error*/
+    LV_FS_RES_FS_ERR,      /*Error in the file system structure */
+    LV_FS_RES_NOT_EX,      /*Driver, file or directory is not exists*/
+    LV_FS_RES_FULL,        /*Disk full*/
+    LV_FS_RES_LOCKED,      /*The file is already opened*/
+    LV_FS_RES_DENIED,      /*Access denied. Check 'fs_open' modes and write protect*/
+    LV_FS_RES_BUSY,        /*The file system now can't handle it, try later*/
+    LV_FS_RES_TOUT,        /*Process time outed*/
+    LV_FS_RES_NOT_IMP,     /*Requested function is not implemented*/
+    LV_FS_RES_OUT_OF_MEM,  /*Not enough memory for an internal operation*/
+    LV_FS_RES_INV_PARAM,   /*Invalid parameter among arguments*/
+    LV_FS_RES_UNKNOWN,     /*Other unknown error*/
+};
+typedef uint8_t lv_fs_res_t;
+
+struct __lv_fs_drv_t;
+
+typedef struct
+{
+    void * file_d;
+    struct __lv_fs_drv_t* drv;
+} lv_fs_file_t;
+
+
+typedef struct
+{
+    void * dir_d;
+    struct __lv_fs_drv_t * drv;
+} lv_fs_dir_t;
+
+enum
+{
+    LV_FS_MODE_WR = 0x01,
+    LV_FS_MODE_RD = 0x02,
+};
+typedef uint8_t lv_fs_mode_t;
+
+typedef struct __lv_fs_drv_t
+{
+    char letter;
+    uint16_t file_size;
+    uint16_t rddir_size;
+    bool (*ready) (void);
+
+    lv_fs_res_t (*open) (void * file_p, const char * path, lv_fs_mode_t mode);
+    lv_fs_res_t (*close) (void * file_p);
+    lv_fs_res_t (*remove) (const char * fn);
+    lv_fs_res_t (*read) (void * file_p, void * buf, uint32_t btr, uint32_t * br);
+    lv_fs_res_t (*write) (void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+    lv_fs_res_t (*seek) (void * file_p, uint32_t pos);
+    lv_fs_res_t (*tell) (void * file_p, uint32_t * pos_p);
+    lv_fs_res_t (*trunc) (void * file_p);
+    lv_fs_res_t (*size) (void * file_p, uint32_t * size_p);
+    lv_fs_res_t (*rename) (const char * oldname, const char * newname);
+    lv_fs_res_t (*free) (uint32_t * total_p, uint32_t * free_p);
+
+    lv_fs_res_t (*dir_open) (void * rddir_p, const char * path);
+    lv_fs_res_t (*dir_read) (void * rddir_p, char * fn);
+    lv_fs_res_t (*dir_close) (void * rddir_p);
+} lv_fs_drv_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the File system interface
+ */
+void lv_fs_init(void);
+
+/**
+ * Add a new drive
+ * @param drv_p pointer to an lv_fs_drv_t structure which is inited with the
+ * corresponding function pointers. The data will be copied so the variable can be local.
+ */
+void lv_fs_add_drv(lv_fs_drv_t * drv_p);
+
+/**
+ * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be returned.
+ * @param letter letter of the drive
+ * @return true: drive is ready; false: drive is not ready
+ */
+bool lv_fs_is_ready(char letter);
+
+/**
+ * Open a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_open (lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mode);
+
+/**
+ * Close an already opened file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_close (lv_fs_file_t * file_p);
+
+/**
+ * Delete a file
+ * @param path path of the file to delete
+ * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_remove (const char * path);
+
+/**
+ * Read from a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param buf pointer to a buffer where the read bytes are stored
+ * @param btr Bytes To Read
+ * @param br the number of real read bytes (Bytes Read). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_read (lv_fs_file_t * file_p, void * buf, uint32_t btr, uint32_t * br);
+
+/**
+ * Write into a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_write (lv_fs_file_t * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+
+/**
+ * Set the position of the 'cursor' (read write pointer) in a file
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param pos the new position expressed in bytes index (0: start of file)
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_seek (lv_fs_file_t * file_p, uint32_t pos);
+
+/**
+ * Give the position of the read write pointer
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param pos_p pointer to store the position of the read write pointer
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+lv_fs_res_t lv_fs_tell (lv_fs_file_t * file_p, uint32_t  * pos);
+
+/**
+ * Truncate the file size to the current position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open )
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_trunc (lv_fs_file_t * file_p);
+
+/**
+ * Give the size of a file bytes
+ * @param file_p pointer to a lv_fs_file_t variable
+ * @param size pointer to a variable to store the size
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_size (lv_fs_file_t * file_p, uint32_t * size);
+
+/**
+ * Rename a file
+ * @param oldname path to the file
+ * @param newname path with the new name
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+lv_fs_res_t lv_fs_rename (const char * oldname, const char * newname);
+
+/**
+ * Initialize a 'fs_dir_t' variable for directory reading
+ * @param rddir_p pointer to a 'fs_read_dir_t' variable
+ * @param path path to a directory
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path);
+
+/**
+ * Read the next filename form a directory.
+ * The name of the directories will begin with '/'
+ * @param rddir_p pointer to an initialized 'fs_rdir_t' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_read (lv_fs_dir_t * rddir_p, char * fn);
+
+/**
+ * Close the directory reading
+ * @param rddir_p pointer to an initialized 'fs_dir_t' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_dir_close (lv_fs_dir_t * rddir_p);
+
+/**
+ * Get the free and total size of a driver in kB
+ * @param letter the driver letter
+ * @param total_p pointer to store the total size [kB]
+ * @param free_p pointer to store the free size [kB]
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_fs_free (char letter, uint32_t * total_p, uint32_t * free_p);
+
+/**
+ * Fill a buffer with the letters of existing drivers
+ * @param buf buffer to store the letters ('\0' added after the last letter)
+ * @return the buffer
+ */
+char *  lv_fs_get_letters(char * buf);
+
+/**
+ * Return with the extension of the filename
+ * @param fn string with a filename
+ * @return pointer to the beginning extension or empty string if no extension
+ */
+const char * lv_fs_get_ext(const char * fn);
+
+/**
+ * Step up one level
+ * @param path pointer to a file name
+ * @return the truncated file name
+ */
+char * lv_fs_up(char * path);
+
+/**
+ * Get the last element of a path (e.g. U:/folder/file -> file)
+ * @param buf buffer to store the letters ('\0' added after the last letter)
+ * @return pointer to the beginning of the last element in the path
+ */
+const char * lv_fs_get_last(const char * path);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*USE_LV_FILESYSTEM*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_FS_H*/

bdk/libs/lvgl/lv_misc/lv_gc.c

@@ -0,0 +1,40 @@
+/**
+ * @file lv_gc.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_gc.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+#if (!defined(LV_ENABLE_GC)) || LV_ENABLE_GC == 0
+LV_ROOTS
+#endif /* LV_ENABLE_GC */
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

bdk/libs/lvgl/lv_misc/lv_gc.h

@@ -0,0 +1,75 @@
+/**
+ * @file lv_gc.h
+ *
+ */
+
+#ifndef LV_GC_H
+#define LV_GC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#include <stdint.h>
+#include "lv_mem.h"
+#include "lv_ll.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_GC_ROOTS(prefix) \
+    prefix lv_ll_t _lv_task_ll;      /*Linked list to store the lv_tasks*/ \
+    prefix lv_ll_t _lv_scr_ll;          /*Linked list of screens*/ \
+    prefix lv_ll_t _lv_drv_ll;\
+    prefix lv_ll_t _lv_file_ll;\
+    prefix lv_ll_t _lv_anim_ll;\
+    prefix void * _lv_def_scr;\
+    prefix void * _lv_act_scr;\
+    prefix void * _lv_top_layer;\
+    prefix void * _lv_sys_layer;\
+    prefix void * _lv_task_act;\
+    prefix void * _lv_indev_list;\
+    prefix void * _lv_disp_list;\
+
+#define LV_NO_PREFIX
+#define LV_ROOTS LV_GC_ROOTS(LV_NO_PREFIX)
+
+#if LV_ENABLE_GC == 1
+#   if LV_MEM_CUSTOM != 1
+#       error "GC requires CUSTOM_MEM"
+#   endif /* LV_MEM_CUSTOM */
+#else /* LV_ENABLE_GC */
+#   define LV_GC_ROOT(x) x
+    LV_GC_ROOTS(extern)
+#endif /* LV_ENABLE_GC */
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_GC_H*/

bdk/libs/lvgl/lv_misc/lv_ll.c

@@ -0,0 +1,376 @@
+/**
+ * @file lv_ll.c
+ * Handle linked lists.
+ * The nodes are dynamically allocated by the 'lv_mem' module,
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdint.h>
+#include <string.h>
+
+#include "lv_ll.h"
+#include "lv_mem.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LL_NODE_META_SIZE (sizeof(lv_ll_node_t*) + sizeof(lv_ll_node_t*))
+#define LL_PREV_P_OFFSET(ll_p) (ll_p->n_size)
+#define LL_NEXT_P_OFFSET(ll_p) (ll_p->n_size + sizeof(lv_ll_node_t*))
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void node_set_prev(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * prev);
+static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * next);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize linked list
+ * @param ll_dsc pointer to ll_dsc variable
+ * @param node_size the size of 1 node in bytes
+ */
+void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
+{
+    ll_p->head = NULL;
+    ll_p->tail = NULL;
+#ifdef LV_MEM_ENV64
+    /*Round the size up to 8*/
+    if(node_size & 0x7) {
+        node_size = node_size & (~0x7);
+        node_size += 8;
+    }
+#else
+    /*Round the size up to 4*/
+    if(node_size & 0x3) {
+        node_size = node_size & (~0x3);
+        node_size += 4;
+    }
+#endif
+
+    ll_p->n_size = node_size;
+}
+
+/**
+ * Add a new head to a linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the new head
+ */
+void * lv_ll_ins_head(lv_ll_t * ll_p)
+{
+    lv_ll_node_t * n_new;
+
+    n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
+
+    if(n_new != NULL) {
+        node_set_prev(ll_p, n_new, NULL);           /*No prev. before the new head*/
+        node_set_next(ll_p, n_new, ll_p->head);     /*After new comes the old head*/
+
+        if(ll_p->head != NULL) { /*If there is old head then before it goes the new*/
+            node_set_prev(ll_p, ll_p->head, n_new);
+        }
+
+        ll_p->head = n_new;         /*Set the new head in the dsc.*/
+        if(ll_p->tail == NULL) {/*If there is no tail (1. node) set the tail too*/
+            ll_p->tail = n_new;
+        }
+    }
+
+    return n_new;
+}
+
+/**
+ * Insert a new node in front of the n_act node
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the new head
+ */
+void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
+{
+    lv_ll_node_t * n_new;
+    lv_ll_node_t * n_prev;
+
+    if(NULL == ll_p || NULL == n_act) return NULL;
+
+    if(lv_ll_get_head(ll_p) == n_act) {
+        n_new = lv_ll_ins_head(ll_p);
+        if(n_new == NULL) return NULL;
+    } else {
+        n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
+        if(n_new == NULL) return NULL;
+
+        n_prev = lv_ll_get_prev(ll_p, n_act);
+        node_set_next(ll_p, n_prev, n_new);
+        node_set_prev(ll_p, n_new, n_prev);
+        node_set_prev(ll_p, n_act, n_new);
+        node_set_next(ll_p, n_new, n_act);
+    }
+
+    return n_new;
+}
+
+/**
+ * Add a new tail to a linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the new tail
+ */
+void * lv_ll_ins_tail(lv_ll_t * ll_p)
+{
+    lv_ll_node_t * n_new;
+
+    n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
+    if(n_new == NULL) return NULL;
+
+    if(n_new != NULL) {
+        node_set_next(ll_p, n_new, NULL); /*No next after the new tail*/
+        node_set_prev(ll_p, n_new, ll_p->tail); /*The prev. before new is tho old tail*/
+        if(ll_p->tail != NULL) {    /*If there is old tail then the new comes after it*/
+            node_set_next(ll_p, ll_p->tail, n_new);
+        }
+
+        ll_p->tail = n_new;      /*Set the new tail in the dsc.*/
+        if(ll_p->head == NULL) { /*If there is no head (1. node) set the head too*/
+            ll_p->head = n_new;
+        }
+    }
+
+    return n_new;
+}
+
+
+/**
+ * Remove the node 'node_p' from 'll_p' linked list.
+ * It does not free the the memory of node.
+ * @param ll_p pointer to the linked list of 'node_p'
+ * @param node_p pointer to node in 'll_p' linked list
+ */
+void lv_ll_rem(lv_ll_t  * ll_p, void * node_p)
+{
+    if(lv_ll_get_head(ll_p) == node_p) {
+        /*The new head will be the node after 'n_act'*/
+        ll_p->head = lv_ll_get_next(ll_p, node_p);
+        if(ll_p->head == NULL) {
+            ll_p->tail = NULL;
+        } else {
+            node_set_prev(ll_p, ll_p->head, NULL);
+        }
+    } else if(lv_ll_get_tail(ll_p) == node_p) {
+        /*The new tail will be the  node before 'n_act'*/
+        ll_p->tail = lv_ll_get_prev(ll_p, node_p);
+        if(ll_p->tail == NULL) {
+            ll_p->head = NULL;
+        } else {
+            node_set_next(ll_p, ll_p->tail, NULL);
+        }
+    } else {
+        lv_ll_node_t * n_prev = lv_ll_get_prev(ll_p, node_p);
+        lv_ll_node_t * n_next = lv_ll_get_next(ll_p, node_p);
+
+        node_set_next(ll_p, n_prev, n_next);
+        node_set_prev(ll_p, n_next, n_prev);
+    }
+}
+
+/**
+ * Remove and free all elements from a linked list. The list remain valid but become empty.
+ * @param ll_p pointer to linked list
+ */
+void lv_ll_clear(lv_ll_t * ll_p)
+{
+    void * i;
+    void * i_next;
+
+    i = lv_ll_get_head(ll_p);
+    i_next = NULL;
+
+    while(i != NULL) {
+        i_next = lv_ll_get_next(ll_p, i);
+
+        lv_ll_rem(ll_p, i);
+        lv_mem_free(i);
+
+        i = i_next;
+    }
+}
+
+/**
+ * Move a node to a new linked list
+ * @param ll_ori_p pointer to the original (old) linked list
+ * @param ll_new_p pointer to the new linked list
+ * @param node pointer to a node
+ */
+void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node)
+{
+    lv_ll_rem(ll_ori_p, node);
+
+    /*Set node as head*/
+    node_set_prev(ll_new_p, node, NULL);
+    node_set_next(ll_new_p, node, ll_new_p->head);
+
+    if(ll_new_p->head != NULL) { /*If there is old head then before it goes the new*/
+        node_set_prev(ll_new_p, ll_new_p->head, node);
+    }
+
+    ll_new_p->head = node;        /*Set the new head in the dsc.*/
+    if(ll_new_p->tail == NULL) {     /*If there is no tail (first node) set the tail too*/
+        ll_new_p->tail = node;
+    }
+}
+
+/**
+ * Return with head node of the linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the head of 'll_p'
+ */
+void * lv_ll_get_head(const lv_ll_t * ll_p)
+{
+    void * head = NULL;
+
+    if(ll_p != NULL)    {
+        head = ll_p->head;
+    }
+
+    return head;
+}
+
+/**
+ * Return with tail node of the linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the head of 'll_p'
+ */
+void * lv_ll_get_tail(const lv_ll_t * ll_p)
+{
+    void * tail = NULL;
+
+    if(ll_p != NULL)    {
+        tail = ll_p->tail;
+    }
+
+    return tail;
+}
+
+/**
+ * Return with the pointer of the next node after 'n_act'
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the next node
+ */
+void * lv_ll_get_next(const lv_ll_t * ll_p, const  void * n_act)
+{
+    void * next = NULL;
+
+    if(ll_p != NULL)    {
+        const lv_ll_node_t * n_act_d = n_act;
+        memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *));
+    }
+
+    return next;
+}
+
+/**
+ * Return with the pointer of the previous node after 'n_act'
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the previous node
+ */
+void * lv_ll_get_prev(const lv_ll_t * ll_p, const  void * n_act)
+{
+    void * prev = NULL;
+
+    if(ll_p != NULL) {
+        const lv_ll_node_t * n_act_d = n_act;
+        memcpy(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *));
+    }
+
+    return prev;
+}
+
+void lv_ll_swap(lv_ll_t * ll_p, void * n1_p, void * n2_p)
+{
+    (void)(ll_p);
+    (void)(n1_p);
+    (void)(n2_p);
+    /*TODO*/
+}
+
+/**
+ * Move a nodw before an other node in the same linked list
+ * @param ll_p pointer to a linked list
+ * @param n_act pointer to node to move
+ * @param n_after pointer to a node which should be after `n_act`
+ */
+void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after)
+{
+    if(n_act == n_after) return;    /*Can't move before itself*/
+
+
+    void * n_before;
+    if(n_after != NULL) n_before = lv_ll_get_prev(ll_p, n_after);
+    else n_before = lv_ll_get_tail(ll_p);        /*if `n_after` is NULL `n_act` should be the new tail*/
+
+    if(n_act == n_before) return;   /*Already before `n_after`*/
+
+    /*It's much easier to remove from the list and add again*/
+    lv_ll_rem(ll_p, n_act);
+
+    /*Add again by setting the prev. and next nodes*/
+    node_set_next(ll_p, n_before, n_act);
+    node_set_prev(ll_p, n_act, n_before);
+    node_set_prev(ll_p, n_after, n_act);
+    node_set_next(ll_p, n_act, n_after);
+
+    /*If `n_act` was moved before NULL then it become the new tail*/
+    if(n_after == NULL) ll_p->tail = n_act;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Set the 'pervious node pointer' of a node
+ * @param ll_p pointer to linked list
+ * @param act pointer to a node which prev. node pointer should be set
+ * @param prev pointer to a node which should be the previous node before 'act'
+ */
+static void node_set_prev(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * prev)
+{
+    if(act == NULL) return;     /*Can't set the prev node of `NULL`*/
+
+    uint32_t node_p_size = sizeof(lv_ll_node_t *);
+    if(prev) memcpy(act + LL_PREV_P_OFFSET(ll_p), &prev, node_p_size);
+    else memset(act + LL_PREV_P_OFFSET(ll_p), 0, node_p_size);
+}
+
+/**
+ * Set the 'next node pointer' of a node
+ * @param ll_p pointer to linked list
+ * @param act pointer to a node which next node pointer should be set
+ * @param next pointer to a node which should be the next node before 'act'
+ */
+static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * next)
+{
+    if(act == NULL) return;     /*Can't set the next node of `NULL`*/
+
+    uint32_t node_p_size = sizeof(lv_ll_node_t *);
+    if(next) memcpy(act + LL_NEXT_P_OFFSET(ll_p), &next, node_p_size);
+    else memset(act + LL_NEXT_P_OFFSET(ll_p), 0, node_p_size);
+}
+

bdk/libs/lvgl/lv_misc/lv_ll.h

@@ -0,0 +1,145 @@
+/**
+ * @file lv_ll.c
+ * Handle linked lists. The nodes are dynamically allocated by the 'lv_mem' module.
+ */
+
+#ifndef LV_LL_H
+#define LV_LL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_mem.h"
+#include <stdint.h>
+#include <stddef.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Dummy type to make handling easier*/
+typedef uint8_t lv_ll_node_t;
+
+/*Description of a linked list*/
+typedef struct
+{
+    uint32_t n_size;
+    lv_ll_node_t* head;
+    lv_ll_node_t* tail;
+} lv_ll_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize linked list
+ * @param ll_dsc pointer to ll_dsc variable
+ * @param node_size the size of 1 node in bytes
+ */
+void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size);
+
+/**
+ * Add a new head to a linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the new head
+ */
+void * lv_ll_ins_head(lv_ll_t * ll_p);
+
+/**
+ * Insert a new node in front of the n_act node
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the new head
+ */
+void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act);
+
+/**
+ * Add a new tail to a linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the new tail
+ */
+void * lv_ll_ins_tail(lv_ll_t * ll_p);
+
+/**
+ * Remove the node 'node_p' from 'll_p' linked list.
+ * It does not free the the memory of node.
+ * @param ll_p pointer to the linked list of 'node_p'
+ * @param node_p pointer to node in 'll_p' linked list
+ */
+void lv_ll_rem(lv_ll_t  * ll_p, void * node_p);
+
+/**
+ * Remove and free all elements from a linked list. The list remain valid but become empty.
+ * @param ll_p pointer to linked list
+ */
+void lv_ll_clear(lv_ll_t * ll_p);
+
+/**
+ * Move a node to a new linked list
+ * @param ll_ori_p pointer to the original (old) linked list
+ * @param ll_new_p pointer to the new linked list
+ * @param node pointer to a node
+ */
+void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node);
+
+/**
+ * Return with head node of the linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the head of 'll_p'
+ */
+void * lv_ll_get_head(const lv_ll_t * ll_p);
+
+/**
+ * Return with tail node of the linked list
+ * @param ll_p pointer to linked list
+ * @return pointer to the head of 'll_p'
+ */
+void * lv_ll_get_tail(const lv_ll_t * ll_p);
+
+/**
+ * Return with the pointer of the next node after 'n_act'
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the next node
+ */
+void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act);
+
+/**
+ * Return with the pointer of the previous node after 'n_act'
+ * @param ll_p pointer to linked list
+ * @param n_act pointer a node
+ * @return pointer to the previous node
+ */
+void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act);
+
+/**
+ * Move a nodw before an other node in the same linked list
+ * @param ll_p pointer to a linked list
+ * @param n_act pointer to node to move
+ * @param n_after pointer to a node which should be after `n_act`
+ */
+void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define LL_READ(list, i) for(i = lv_ll_get_head(&list); i != NULL; i = lv_ll_get_next(&list, i))
+
+#define LL_READ_BACK(list, i) for(i = lv_ll_get_tail(&list); i != NULL; i = lv_ll_get_prev(&list, i))
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

bdk/libs/lvgl/lv_misc/lv_log.c

@@ -0,0 +1,82 @@
+/**
+ * @file lv_log.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_log.h"
+#if USE_LV_LOG
+
+#if LV_LOG_PRINTF
+#include <string.h>
+#include "../../../mem/heap.h"
+#include "../../../soc/uart.h"
+#include "../../../utils/sprintf.h"
+#endif
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static void (*print_cb)(lv_log_level_t, const char *, uint32_t,  const char *);
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Register custom print (or anything else) function to call when log is added
+ * @param f a function pointer:
+ *          `void my_print (lv_log_level_t level, const char * file, uint32_t line, const char * dsc)`
+ */
+void lv_log_register_print(void f(lv_log_level_t, const char *, uint32_t,  const char *))
+{
+    print_cb = f;
+}
+
+/**
+ * Add a log
+ * @param level the level of log. (From `lv_log_level_t` enum)
+ * @param file name of the file when the log added
+ * @param line line number in the source code where the log added
+ * @param dsc description of the log
+ */
+void lv_log_add(lv_log_level_t level, const char * file, int line, const char * dsc)
+{
+    if(level >= _LV_LOG_LEVEL_NUM) return;      /*Invalid level*/
+
+    if(level >= LV_LOG_LEVEL) {
+
+#if LV_LOG_PRINTF
+        static const char * lvl_prefix[] = {"Trace", "Info", "Warn", "Error"};
+        char *log = (char *)malloc(0x1000);
+        s_printf(log, "%s: %s \t(%s #%d)\r\n", lvl_prefix[level], dsc,  file, line);
+        uart_send(UART_B, (u8 *)log, strlen(log) + 1);
+        //gfx_printf("%s: %s \t(%s #%d)\n", lvl_prefix[level], dsc,  file, line);
+#else
+        if(print_cb) print_cb(level, file, line, dsc);
+#endif
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*USE_LV_LOG*/

bdk/libs/lvgl/lv_misc/lv_log.h

@@ -0,0 +1,86 @@
+/**
+ * @file lv_log.h
+ *
+ */
+
+#ifndef LV_LOG_H
+#define LV_LOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+#include <stdint.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/*Possible log level. For compatibility declare it independently from `USE_LV_LOG`*/
+
+#define LV_LOG_LEVEL_TRACE 0     /*A lot of logs to give detailed information*/
+#define LV_LOG_LEVEL_INFO  1     /*Log important events*/
+#define LV_LOG_LEVEL_WARN  2     /*Log if something unwanted happened but didn't caused problem*/
+#define LV_LOG_LEVEL_ERROR 3     /*Only critical issue, when the system may fail*/
+#define _LV_LOG_LEVEL_NUM  4
+
+typedef int8_t lv_log_level_t;
+
+#if USE_LV_LOG
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Register custom print (or anything else) function to call when log is added
+ * @param f a function pointer:
+ *          `void my_print (lv_log_level_t level, const char * file, uint32_t line, const char * dsc)`
+ */
+void lv_log_register_print(void f(lv_log_level_t, const char *, uint32_t,  const char *));
+
+/**
+ * Add a log
+ * @param level the level of log. (From `lv_log_level_t` enum)
+ * @param file name of the file when the log added
+ * @param line line number in the source code where the log added
+ * @param dsc description of the log
+ */
+void lv_log_add(lv_log_level_t level, const char * file, int line, const char * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define LV_LOG_TRACE(dsc)   lv_log_add(LV_LOG_LEVEL_TRACE, __FILE__, __LINE__, dsc);
+#define LV_LOG_INFO(dsc)    lv_log_add(LV_LOG_LEVEL_INFO, __FILE__, __LINE__, dsc);
+#define LV_LOG_WARN(dsc)    lv_log_add(LV_LOG_LEVEL_WARN, __FILE__, __LINE__, dsc);
+#define LV_LOG_ERROR(dsc)   lv_log_add(LV_LOG_LEVEL_ERROR, __FILE__, __LINE__, dsc);
+
+#else /*USE_LV_LOG*/
+
+/*Do nothing if `USE_LV_LOG  0`*/
+#define lv_log_add(level, file, line, dsc) {;}
+#define LV_LOG_TRACE(dsc) {;}
+#define LV_LOG_INFO(dsc) {;}
+#define LV_LOG_WARN(dsc) {;}
+#define LV_LOG_ERROR(dsc) {;}
+#endif /*USE_LV_LOG*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_LOG_H*/

bdk/libs/lvgl/lv_misc/lv_math.c

@@ -0,0 +1,165 @@
+/**
+ * @file lv_math.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_math.h"
+#include <stdbool.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static int16_t sin0_90_table[] = {
+    0,     572,    1144,   1715,   2286,   2856,   3425,   3993,   4560,   5126,
+    5690,  6252,   6813,   7371,   7927,   8481,   9032,   9580,   10126,  10668,
+    11207, 11743,  12275,  12803,  13328,  13848,  14364,  14876,  15383,  15886,
+    16383, 16876,  17364,  17846,  18323,  18794,  19260,  19720,  20173,  20621,
+    21062, 21497,  21925,  22347,  22762,  23170,  23571,  23964,  24351,  24730,
+    25101, 25465,  25821,  26169,  26509,  26841,  27165,  27481,  27788,  28087,
+    28377, 28659,  28932,  29196,  29451,  29697,  29934,  30162,  30381,  30591,
+    30791, 30982,  31163,  31335,  31498,  31650,  31794,  31927,  32051,  32165,
+    32269, 32364,  32448,  32523,  32587,  32642,  32687,  32722,  32747,  32762,
+	32767
+};
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Convert a number to string
+ * @param num a number
+ * @param buf pointer to a `char` buffer. The result will be stored here (max 10 elements)
+ * @return same as `buf` (just for convenience)
+ */
+char * lv_math_num_to_str(int32_t num, char * buf)
+{
+    char * buf_ori = buf;
+    if(num == 0) {
+        buf[0] = '0';
+        buf[1] = '\0';
+        return buf;
+    } else if(num < 0) {
+        (*buf) = '-';
+        buf++;
+        num = LV_MATH_ABS(num);
+    }
+    uint32_t output = 0;
+    int8_t i;
+
+    for(i = 31; i >= 0; i--) {
+        if((output & 0xF) >= 5)
+            output += 3;
+        if(((output & 0xF0) >> 4) >= 5)
+            output += (3 << 4);
+        if(((output & 0xF00) >> 8) >= 5)
+            output += (3 << 8);
+        if(((output & 0xF000) >> 12) >= 5)
+            output += (3 << 12);
+        if(((output & 0xF0000) >> 16) >= 5)
+            output += (3 << 16);
+        if(((output & 0xF00000) >> 20) >= 5)
+            output += (3 << 20);
+        if(((output & 0xF000000) >> 24) >= 5)
+            output += (3 << 24);
+        if(((output & 0xF0000000) >> 28) >= 5)
+            output += (3 << 28);
+        output = (output << 1) | ((num >> i) & 1);
+    }
+
+    uint8_t digit;
+    bool leading_zero_ready = false;
+    for(i = 28; i >= 0; i -= 4) {
+        digit = ((output >> i) & 0xF) + '0';
+        if(digit == '0' && leading_zero_ready == false) continue;
+
+        leading_zero_ready = true;
+        (*buf) = digit;
+        buf++;
+    }
+
+    (*buf) = '\0';
+
+    return buf_ori;
+}
+
+/**
+ * Return with sinus of an angle
+ * @param angle
+ * @return sinus of 'angle'. sin(-90) = -32767, sin(90) = 32767
+ */
+int16_t lv_trigo_sin(int16_t angle)
+{
+    int16_t ret = 0;
+    angle = angle % 360;
+
+    if(angle < 0) angle = 360 + angle;
+
+    if(angle < 90) {
+        ret = sin0_90_table[angle];
+    } else if(angle >= 90 && angle < 180) {
+        angle = 180 - angle;
+        ret = sin0_90_table[angle];
+    } else if(angle >= 180 && angle < 270) {
+        angle = angle - 180;
+        ret = - sin0_90_table[angle];
+    } else { /*angle >=270*/
+        angle = 360 - angle;
+        ret = - sin0_90_table[angle];
+    }
+
+    return ret;
+}
+
+/**
+ * Calculate a value of a Cubic Bezier function.
+ * @param t time in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u0 start values in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u1 control value 1 values in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u2 control value 2 in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u3 end values in range of [0..LV_BEZIER_VAL_MAX]
+ * @return the value calculated from the given parameters in range of [0..LV_BEZIER_VAL_MAX]
+ */
+int32_t lv_bezier3(uint32_t t, int32_t u0, int32_t u1, int32_t u2, int32_t u3)
+{
+    uint32_t t_rem = 1024 - t;
+    uint32_t t_rem2 = (t_rem * t_rem) >> 10;
+    uint32_t t_rem3 = (t_rem2 * t_rem) >> 10;
+    uint32_t t2 = (t * t) >> 10;
+    uint32_t t3 = (t2 * t) >> 10;
+
+
+    uint32_t v1 = ((uint32_t)t_rem3 * u0) >> 10;
+    uint32_t v2 = ((uint32_t)3 * t_rem2 * t * u1) >> 20;
+    uint32_t v3 = ((uint32_t)3 * t_rem * t2 * u2) >> 20;
+    uint32_t v4 = ((uint32_t)t3 * u3) >> 10;
+
+    return v1 + v2 + v3 + v4;
+
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+

bdk/libs/lvgl/lv_misc/lv_math.h

@@ -0,0 +1,73 @@
+/**
+ * @file math_base.h
+ *
+ */
+
+#ifndef LV_MATH_H
+#define LV_MATH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdint.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_MATH_MIN(a,b) ((a) < (b) ? (a) : (b))
+#define LV_MATH_MAX(a,b) ((a) > (b) ? (a) : (b))
+#define LV_MATH_ABS(x) ((x) > 0 ? (x) : (-(x)))
+
+#define LV_TRIGO_SIN_MAX    32767
+#define LV_TRIGO_SHIFT      15      /* >> LV_TRIGO_SHIFT to normalize*/
+
+#define LV_BEZIER_VAL_MAX       1024    /*Max time in Bezier functions (not [0..1] to use integers) */
+#define LV_BEZIER_VAL_SHIFT     10      /*log2(LV_BEZIER_VAL_MAX): used to normalize up scaled values*/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+/**
+ * Convert a number to string
+ * @param num a number
+ * @param buf pointer to a `char` buffer. The result will be stored here (max 10 elements)
+ * @return same as `buf` (just for convenience)
+ */
+char * lv_math_num_to_str(int32_t num, char * buf);
+
+/**
+ * Return with sinus of an angle
+ * @param angle
+ * @return sinus of 'angle'. sin(-90) = -32767, sin(90) = 32767
+ */
+int16_t lv_trigo_sin(int16_t angle);
+
+/**
+ * Calculate a value of a Cubic Bezier function.
+ * @param t time in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u0 start values in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u1 control value 1 values in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u2 control value 2 in range of [0..LV_BEZIER_VAL_MAX]
+ * @param u3 end values in range of [0..LV_BEZIER_VAL_MAX]
+ * @return the value calculated from the given parameters in range of [0..LV_BEZIER_VAL_MAX]
+ */
+int32_t lv_bezier3(uint32_t t, int32_t u0, int32_t u1, int32_t u2, int32_t u3);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

bdk/libs/lvgl/lv_misc/lv_mem.c

@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) 2019-2020 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * @file lv_mem.c
+ * General and portable implementation of malloc and free.
+ * The dynamic memory monitoring is also supported.
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_mem.h"
+#include "lv_math.h"
+#include <string.h>
+
+#include <assert.h>
+
+#if LV_MEM_CUSTOM != 0
+#include LV_MEM_CUSTOM_INCLUDE
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_MEM_ADD_JUNK     0   /*Add memory junk on alloc (0xaa) and free(0xbb) (just for testing purposes)*/
+
+
+#ifdef LV_MEM_ENV64
+# define MEM_UNIT uint64_t
+#else
+# define MEM_UNIT uint32_t
+#endif
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+#if LV_ENABLE_GC == 0 /*gc custom allocations must not include header*/
+
+/*The size of this union must be 32 bytes (uint32_t * 8)*/
+typedef union {
+    struct {
+        MEM_UNIT used: 1;       //1: if the entry is used
+        MEM_UNIT d_size: 31;    //Size of the data
+    };
+    MEM_UNIT header;            //The header (used + d_size)
+    MEM_UNIT align[8];          //Align header size to MEM_UNIT * 8 bytes
+} lv_mem_header_t;
+
+static_assert(sizeof(lv_mem_header_t) == 32, "Node header must be 32 bytes!");
+
+typedef struct {
+    lv_mem_header_t header;
+    uint8_t first_data;        /*First data byte in the allocated data (Just for easily create a pointer)*/
+} lv_mem_ent_t;
+
+#endif /* LV_ENABLE_GC */
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+#if LV_MEM_CUSTOM == 0
+static lv_mem_ent_t  * ent_get_next(lv_mem_ent_t * act_e);
+static void * ent_alloc(lv_mem_ent_t * e, uint32_t size);
+static void ent_trunc(lv_mem_ent_t * e, uint32_t size);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+#if LV_MEM_CUSTOM == 0
+static uint8_t * work_mem;
+#endif
+
+static uint32_t zero_mem;       /*Give the address of this variable if 0 byte should be allocated*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initiaiize the dyn_mem module (work memory and other variables)
+ */
+void lv_mem_init(void)
+{
+#if LV_MEM_CUSTOM == 0
+
+#if LV_MEM_ADR == 0
+    /*Allocate a large array to store the dynamically allocated data*/
+    static LV_MEM_ATTR MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)];
+    work_mem = (uint8_t *) work_mem_int;
+#else
+    work_mem = (uint8_t *) LV_MEM_ADR;
+#endif
+
+    lv_mem_ent_t * full = (lv_mem_ent_t *)work_mem;
+    full->header.used = 0;
+    /*The total mem size id reduced by the first header and the close patterns */
+    full->header.d_size = LV_MEM_SIZE - sizeof(lv_mem_header_t);
+#endif
+}
+
+/**
+ * Allocate a memory dynamically
+ * @param size size of the memory to allocate in bytes
+ * @return pointer to the allocated memory
+ */
+void * lv_mem_alloc(uint32_t size)
+{
+    if(size == 0) {
+        return &zero_mem;
+    }
+
+    /*Round the size to lv_mem_header_t*/
+    if(size & (sizeof(lv_mem_header_t) - 1)) {
+        size = size & (~(sizeof(lv_mem_header_t) - 1));
+        size += sizeof(lv_mem_header_t);
+    }
+
+    void * alloc = NULL;
+
+#if LV_MEM_CUSTOM == 0 /*Use the allocation from dyn_mem*/
+    lv_mem_ent_t * e = NULL;
+
+    //Search for a appropriate entry
+    do {
+        //Get the next entry
+        e = ent_get_next(e);
+
+        /*If there is next entry then try to allocate there*/
+        if(e != NULL) {
+            alloc = ent_alloc(e, size);
+        }
+        //End if there is not next entry OR the alloc. is successful
+    } while(e != NULL && alloc == NULL);
+
+
+#else  /*Use custom, user defined malloc function*/
+#if LV_ENABLE_GC == 1 /*gc must not include header*/
+    alloc = LV_MEM_CUSTOM_ALLOC(size);
+#else /* LV_ENABLE_GC */
+    /*Allocate a header too to store the size*/
+    alloc = LV_MEM_CUSTOM_ALLOC(size + sizeof(lv_mem_header_t));
+    if(alloc != NULL) {
+        ((lv_mem_ent_t *) alloc)->header.d_size = size;
+        ((lv_mem_ent_t *) alloc)->header.used = 1;
+        alloc = &((lv_mem_ent_t *) alloc)->first_data;
+    }
+#endif /* LV_ENABLE_GC */
+#endif /* LV_MEM_CUSTOM */
+
+#if LV_MEM_ADD_JUNK
+    if(alloc != NULL) memset(alloc, 0xaa, size);
+#endif
+
+    if(alloc == NULL) LV_LOG_WARN("Couldn't allocate memory");
+
+    return alloc;
+}
+
+/**
+ * Free an allocated data
+ * @param data pointer to an allocated memory
+ */
+void lv_mem_free(const void * data)
+{
+    if(data == &zero_mem) return;
+    if(data == NULL) return;
+
+
+#if LV_MEM_ADD_JUNK
+    memset((void *)data, 0xbb, lv_mem_get_size(data));
+#endif
+
+#if LV_ENABLE_GC==0
+    /*e points to the header*/
+    lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *) data - sizeof(lv_mem_header_t));
+    e->header.used = 0;
+#endif
+
+#if LV_MEM_CUSTOM == 0
+#if LV_MEM_AUTO_DEFRAG
+    /* Make a simple defrag.
+     * Join the following free entries after this*/
+    lv_mem_ent_t * e_next;
+    e_next = ent_get_next(e);
+    while(e_next != NULL) {
+        if(e_next->header.used == 0) {
+            e->header.d_size += e_next->header.d_size + sizeof(e->header);
+        } else {
+            break;
+        }
+        e_next = ent_get_next(e_next);
+    }
+#endif
+#else /*Use custom, user defined free function*/
+#if LV_ENABLE_GC==0
+    LV_MEM_CUSTOM_FREE(e);
+#else
+    LV_MEM_CUSTOM_FREE((void*)data);
+#endif /*LV_ENABLE_GC*/
+#endif
+}
+
+/**
+ * Reallocate a memory with a new size. The old content will be kept.
+ * @param data pointer to an allocated memory.
+ * Its content will be copied to the new memory block and freed
+ * @param new_size the desired new size in byte
+ * @return pointer to the new memory
+ */
+
+#if LV_ENABLE_GC==0
+
+void * lv_mem_realloc(void * data_p, uint32_t new_size)
+{
+    /*Round the size to lv_mem_header_t*/
+    if(new_size & (sizeof(lv_mem_header_t) - 1)) {
+        new_size = new_size & (~(sizeof(lv_mem_header_t) - 1));
+        new_size += sizeof(lv_mem_header_t);
+    }
+
+    /*data_p could be previously freed pointer (in this case it is invalid)*/
+    if(data_p != NULL) {
+        lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *) data_p - sizeof(lv_mem_header_t));
+        if(e->header.used == 0) {
+            data_p = NULL;
+        }
+    }
+
+    uint32_t old_size = lv_mem_get_size(data_p);
+    if(old_size == new_size) return data_p;     /*Also avoid reallocating the same memory*/
+
+#if LV_MEM_CUSTOM == 0
+    /* Only truncate the memory is possible
+     * If the 'old_size' was extended by a header size in 'ent_trunc' it avoids reallocating this same memory */
+    if(new_size < old_size) {
+        lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *) data_p - sizeof(lv_mem_header_t));
+        ent_trunc(e, new_size);
+        return &e->first_data;
+    }
+#endif
+
+    void * new_p;
+    new_p = lv_mem_alloc(new_size);
+
+    if(new_p != NULL && data_p != NULL) {
+        /*Copy the old data to the new. Use the smaller size*/
+        if(old_size != 0) {
+            memcpy(new_p, data_p, LV_MATH_MIN(new_size, old_size));
+            lv_mem_free(data_p);
+        }
+    }
+
+
+    if(new_p == NULL) LV_LOG_WARN("Couldn't allocate memory");
+
+    return new_p;
+}
+
+#else /* LV_ENABLE_GC */
+
+void * lv_mem_realloc(void * data_p, uint32_t new_size)
+{
+    void * new_p = LV_MEM_CUSTOM_REALLOC(data_p, new_size);
+    if(new_p == NULL) LV_LOG_WARN("Couldn't allocate memory");
+    return new_p;
+}
+
+#endif /* lv_enable_gc */
+
+/**
+ * Join the adjacent free memory blocks
+ */
+void lv_mem_defrag(void)
+{
+#if LV_MEM_CUSTOM == 0
+    lv_mem_ent_t * e_free;
+    lv_mem_ent_t * e_next;
+    e_free = ent_get_next(NULL);
+
+    while(1) {
+        /*Search the next free entry*/
+        while(e_free != NULL) {
+            if(e_free->header.used != 0) {
+                e_free = ent_get_next(e_free);
+            } else {
+                break;
+            }
+        }
+
+        if(e_free == NULL) return;
+
+        /*Joint the following free entries to the free*/
+        e_next = ent_get_next(e_free);
+        while(e_next != NULL) {
+            if(e_next->header.used == 0) {
+                e_free->header.d_size += e_next->header.d_size + sizeof(e_next->header);
+            } else {
+                break;
+            }
+
+            e_next = ent_get_next(e_next);
+        }
+
+        if(e_next == NULL) return;
+
+        /*Continue from the lastly checked entry*/
+        e_free = e_next;
+    }
+#endif
+}
+
+/**
+ * Give information about the work memory of dynamic allocation
+ * @param mon_p pointer to a dm_mon_p variable,
+ *              the result of the analysis will be stored here
+ */
+void lv_mem_monitor(lv_mem_monitor_t * mon_p)
+{
+    /*Init the data*/
+    memset(mon_p, 0, sizeof(lv_mem_monitor_t));
+#if LV_MEM_CUSTOM == 0
+    lv_mem_ent_t * e;
+    e = NULL;
+
+    e = ent_get_next(e);
+
+    while(e != NULL)  {
+        if(e->header.used == 0) {
+            mon_p->free_cnt++;
+            mon_p->free_size += e->header.d_size;
+            if(e->header.d_size > mon_p->free_biggest_size) {
+                mon_p->free_biggest_size = e->header.d_size;
+            }
+        } else {
+            mon_p->used_cnt++;
+        }
+
+        e = ent_get_next(e);
+    }
+    mon_p->total_size = LV_MEM_SIZE;
+    mon_p->used_pct = 100 - ((uint64_t)100U * mon_p->free_size) / mon_p->total_size;
+    mon_p->frag_pct = (uint32_t)mon_p->free_biggest_size * 100U / mon_p->free_size;
+    mon_p->frag_pct = 100 - mon_p->frag_pct;
+#endif
+}
+
+/**
+ * Give the size of an allocated memory
+ * @param data pointer to an allocated memory
+ * @return the size of data memory in bytes
+ */
+
+#if LV_ENABLE_GC==0
+
+uint32_t lv_mem_get_size(const void * data)
+{
+    if(data == NULL) return 0;
+    if(data == &zero_mem) return 0;
+
+    lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *) data - sizeof(lv_mem_header_t));
+
+    return e->header.d_size;
+}
+
+#else /* LV_ENABLE_GC */
+
+uint32_t lv_mem_get_size(const void * data)
+{
+    return LV_MEM_CUSTOM_GET_SIZE(data);
+}
+
+#endif /*LV_ENABLE_GC*/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#if LV_MEM_CUSTOM == 0
+/**
+ * Give the next entry after 'act_e'
+ * @param act_e pointer to an entry
+ * @return pointer to an entry after 'act_e'
+ */
+static lv_mem_ent_t * ent_get_next(lv_mem_ent_t * act_e)
+{
+    lv_mem_ent_t * next_e = NULL;
+
+    if(act_e == NULL) { /*NULL means: get the first entry*/
+        next_e = (lv_mem_ent_t *) work_mem;
+    } else { /*Get the next entry */
+        uint8_t * data = &act_e->first_data;
+        next_e = (lv_mem_ent_t *)&data[act_e->header.d_size];
+
+        if(&next_e->first_data >= &work_mem[LV_MEM_SIZE]) next_e = NULL;
+    }
+
+    return next_e;
+}
+
+
+/**
+ * Try to do the real allocation with a given size
+ * @param e try to allocate to this entry
+ * @param size size of the new memory in bytes
+ * @return pointer to the allocated memory or NULL if not enough memory in the entry
+ */
+static void * ent_alloc(lv_mem_ent_t * e, uint32_t size)
+{
+    void * alloc = NULL;
+
+    /*If the memory is free and big enough then use it */
+    if(e->header.used == 0 && e->header.d_size >= size) {
+        /*Truncate the entry to the desired size */
+        ent_trunc(e, size),
+
+                  e->header.used = 1;
+
+        /*Save the allocated data*/
+        alloc = &e->first_data;
+    }
+
+    return alloc;
+}
+
+/**
+ * Truncate the data of entry to the given size
+ * @param e Pointer to an entry
+ * @param size new size in bytes
+ */
+static void ent_trunc(lv_mem_ent_t * e, uint32_t size)
+{
+    /*Don't let empty space only for a header without data*/
+    if(e->header.d_size == size + sizeof(lv_mem_header_t)) {
+        size = e->header.d_size;
+    }
+
+    /* Create the new entry after the current if there is space for it */
+    if(e->header.d_size != size) {
+        uint8_t * e_data = &e->first_data;
+        lv_mem_ent_t * after_new_e = (lv_mem_ent_t *)&e_data[size];
+        after_new_e->header.used = 0;
+        after_new_e->header.d_size = e->header.d_size - size - sizeof(lv_mem_header_t);
+    }
+
+    /* Set the new size for the original entry */
+    e->header.d_size = size;
+}
+
+#endif

bdk/libs/lvgl/lv_misc/lv_mem.h

@@ -0,0 +1,127 @@
+/**
+ * @file lv_mem.h
+ *
+ */
+
+#ifndef LV_MEM_H
+#define LV_MEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+#include "lv_log.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+// Check windows
+#ifdef __WIN64
+//# define LV_MEM_ENV64
+#endif
+
+// Check GCC
+#ifdef __GNUC__
+# if defined(__x86_64__) || defined(__ppc64__)
+//#   define LV_MEM_ENV64
+# endif
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct
+{
+    uint32_t total_size;
+    uint32_t free_cnt;
+    uint32_t free_size;
+    uint32_t free_biggest_size;
+    uint32_t used_cnt;
+    uint8_t used_pct;
+    uint8_t frag_pct;
+} lv_mem_monitor_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+
+/**
+ * Initiaize the dyn_mem module (work memory and other variables)
+ */
+void lv_mem_init(void);
+
+/**
+ * Allocate a memory dynamically
+ * @param size size of the memory to allocate in bytes
+ * @return pointer to the allocated memory
+ */
+void * lv_mem_alloc(uint32_t size);
+
+/**
+ * Free an allocated data
+ * @param data pointer to an allocated memory
+ */
+void lv_mem_free(const void * data);
+
+/**
+ * Reallocate a memory with a new size. The old content will be kept.
+ * @param data pointer to an allocated memory.
+ * Its content will be copied to the new memory block and freed
+ * @param new_size the desired new size in byte
+ * @return pointer to the new memory
+ */
+void * lv_mem_realloc(void * data_p, uint32_t new_size);
+
+/**
+ * Join the adjacent free memory blocks
+ */
+void lv_mem_defrag(void);
+
+/**
+ * Give information about the work memory of dynamic allocation
+ * @param mon_p pointer to a dm_mon_p variable,
+ *              the result of the analysis will be stored here
+ */
+void lv_mem_monitor(lv_mem_monitor_t * mon_p);
+
+/**
+ * Give the size of an allocated memory
+ * @param data pointer to an allocated memory
+ * @return the size of data memory in bytes
+ */
+uint32_t lv_mem_get_size(const void * data);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**
+ * Halt on NULL pointer
+ * p pointer to a memory
+ */
+#if USE_LV_LOG == 0
+# define  lv_mem_assert(p) {if(p == NULL) while(1); }
+#else
+# define  lv_mem_assert(p) {if(p == NULL) {LV_LOG_ERROR("Out of memory!"); while(1); }}
+#endif
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_MEM_H*/
+

bdk/libs/lvgl/lv_misc/lv_misc.mk

@@ -0,0 +1,19 @@
+CSRCS += lv_font.c
+CSRCS += lv_circ.c
+CSRCS += lv_area.c
+CSRCS += lv_task.c
+CSRCS += lv_fs.c
+CSRCS += lv_anim.c
+CSRCS += lv_mem.c
+CSRCS += lv_ll.c
+CSRCS += lv_color.c
+CSRCS += lv_txt.c
+CSRCS += lv_ufs.c
+CSRCS += lv_math.c
+CSRCS += lv_log.c
+CSRCS += lv_gc.c
+
+DEPPATH += --dep-path $(LVGL_DIR)/lvgl/lv_misc
+VPATH += :$(LVGL_DIR)/lvgl/lv_misc
+
+CFLAGS += "-I$(LVGL_DIR)/lvgl/lv_misc"

bdk/libs/lvgl/lv_misc/lv_symbol_def.h

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LV_SYMBOL_DEF_H
+#define LV_SYMBOL_DEF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+/*
+ * With no UTF-8 support (192- 255) (192..241 is used)
+ *
+ * With UTF-8 support (in Supplemental Private Use Area-A): 0xF800 .. 0xF831
+ * - Basic symbols:     0xE000..0xE01F
+ * - File symbols:      0xE020..0xE03F
+ * - Feedback symbols:  0xE040..0xE05F
+ * - Reserved:          0xE060..0xE07F
+ */
+
+#if LV_TXT_UTF8 == 0
+#define LV_SYMBOL_GLYPH_FIRST  0xC0
+#define SYMBOL_DOT             _SYMBOL_VALUE1(C0)
+#define SYMBOL_CLOCK           _SYMBOL_VALUE1(C1)
+#define SYMBOL_LIST            _SYMBOL_VALUE1(C2)
+#define SYMBOL_OK              _SYMBOL_VALUE1(C3)
+#define SYMBOL_CLOSE           _SYMBOL_VALUE1(C4)
+#define SYMBOL_POWER           _SYMBOL_VALUE1(C5)
+#define SYMBOL_SETTINGS        _SYMBOL_VALUE1(C6)
+#define SYMBOL_TRASH           _SYMBOL_VALUE1(C7)
+#define SYMBOL_HOME            _SYMBOL_VALUE1(C8)
+#define SYMBOL_DOWNLOAD        _SYMBOL_VALUE1(C9)
+#define SYMBOL_DRIVE           _SYMBOL_VALUE1(CA)
+#define SYMBOL_REFRESH         _SYMBOL_VALUE1(CB)
+#define SYMBOL_REBOOT          _SYMBOL_VALUE1(CC)
+#define SYMBOL_CHIP            _SYMBOL_VALUE1(CD)
+#define SYMBOL_SD              _SYMBOL_VALUE1(CE)
+#define SYMBOL_CIRCUIT         _SYMBOL_VALUE1(CF)
+#define SYMBOL_EDIT            _SYMBOL_VALUE1(D0)
+#define SYMBOL_FILE_ALT        _SYMBOL_VALUE1(D1)
+#define SYMBOL_FILE_CODE       _SYMBOL_VALUE1(D2)
+#define SYMBOL_FILE_ARC        _SYMBOL_VALUE1(D3)
+#define SYMBOL_TEMPERATURE     _SYMBOL_VALUE1(D4)
+#define SYMBOL_MODULES         _SYMBOL_VALUE1(D5)
+#define SYMBOL_MODULES_ALT     _SYMBOL_VALUE1(D6)
+#define SYMBOL_LEFT            _SYMBOL_VALUE1(D7)
+#define SYMBOL_RIGHT           _SYMBOL_VALUE1(D8)
+#define SYMBOL_KEY             _SYMBOL_VALUE1(D9)
+#define SYMBOL_INFO            _SYMBOL_VALUE1(DA)
+#define SYMBOL_WARNING         _SYMBOL_VALUE1(DB)
+#define SYMBOL_SHUFFLE         _SYMBOL_VALUE1(DC)
+#define SYMBOL_UP              _SYMBOL_VALUE1(DD)
+#define SYMBOL_DOWN            _SYMBOL_VALUE1(DE)
+#define SYMBOL_BRIGHTNESS      _SYMBOL_VALUE1(DF)
+#define SYMBOL_DIRECTORY       _SYMBOL_VALUE1(E0)
+#define SYMBOL_UPLOAD          _SYMBOL_VALUE1(E1)
+#define SYMBOL_USB             _SYMBOL_VALUE1(E2)
+#define SYMBOL_TOOLS           _SYMBOL_VALUE1(E3)
+#define SYMBOL_COPY            _SYMBOL_VALUE1(E4)
+#define SYMBOL_SAVE            _SYMBOL_VALUE1(E5)
+#define SYMBOL_CHARGE          _SYMBOL_VALUE1(E6)
+#define SYMBOL_HINT            _SYMBOL_VALUE1(E7)
+#define SYMBOL_KEYBOARD        _SYMBOL_VALUE1(E8)
+#define SYMBOL_GPS             _SYMBOL_VALUE1(E9)
+#define SYMBOL_FILE            _SYMBOL_VALUE1(EA)
+#define SYMBOL_CAMERA          _SYMBOL_VALUE1(EB)
+#define SYMBOL_BATTERY_FULL    _SYMBOL_VALUE1(EC)
+#define SYMBOL_BATTERY_3       _SYMBOL_VALUE1(ED)
+#define SYMBOL_BATTERY_2       _SYMBOL_VALUE1(EE)
+#define SYMBOL_BATTERY_1       _SYMBOL_VALUE1(EF)
+#define SYMBOL_BATTERY_EMPTY   _SYMBOL_VALUE1(F0)
+#define SYMBOL_SHRK            _SYMBOL_VALUE1(F1)
+#define LV_SYMBOL_GLYPH_LAST   0xF1
+#define SYMBOL_DUMMY           _SYMBOL_VALUE1(FF)       /*Invalid symbol. If written before a string then `lv_img` will show it as a label*/
+
+#else
+#define LV_SYMBOL_GLYPH_FIRST  0xF800
+#define SYMBOL_DOT             _SYMBOL_VALUE3(EF,A0,80)
+#define SYMBOL_CLOCK           _SYMBOL_VALUE3(EF,A0,81)
+#define SYMBOL_LIST            _SYMBOL_VALUE3(EF,A0,82)
+#define SYMBOL_OK              _SYMBOL_VALUE3(EF,A0,83)
+#define SYMBOL_CLOSE           _SYMBOL_VALUE3(EF,A0,84)
+#define SYMBOL_POWER           _SYMBOL_VALUE3(EF,A0,85)
+#define SYMBOL_SETTINGS        _SYMBOL_VALUE3(EF,A0,86)
+#define SYMBOL_TRASH           _SYMBOL_VALUE3(EF,A0,87)
+#define SYMBOL_HOME            _SYMBOL_VALUE3(EF,A0,88)
+#define SYMBOL_DOWNLOAD        _SYMBOL_VALUE3(EF,A0,89)
+#define SYMBOL_DRIVE           _SYMBOL_VALUE3(EF,A0,8A)
+#define SYMBOL_REFRESH         _SYMBOL_VALUE3(EF,A0,8B)
+#define SYMBOL_REBOOT          _SYMBOL_VALUE3(EF,A0,8C)
+#define SYMBOL_CHIP            _SYMBOL_VALUE3(EF,A0,8D)
+#define SYMBOL_SD              _SYMBOL_VALUE3(EF,A0,8E)
+#define SYMBOL_CIRCUIT         _SYMBOL_VALUE3(EF,A0,8F)
+#define SYMBOL_EDIT            _SYMBOL_VALUE3(EF,A0,90)
+#define SYMBOL_FILE_ALT        _SYMBOL_VALUE3(EF,A0,91)
+#define SYMBOL_FILE_CODE       _SYMBOL_VALUE3(EF,A0,92)
+#define SYMBOL_FILE_ARC        _SYMBOL_VALUE3(EF,A0,93)
+#define SYMBOL_TEMPERATURE     _SYMBOL_VALUE3(EF,A0,94)
+#define SYMBOL_MODULES         _SYMBOL_VALUE3(EF,A0,95)
+#define SYMBOL_MODULES_ALT     _SYMBOL_VALUE3(EF,A0,96)
+#define SYMBOL_LEFT            _SYMBOL_VALUE3(EF,A0,97)
+#define SYMBOL_RIGHT           _SYMBOL_VALUE3(EF,A0,98)
+#define SYMBOL_KEY             _SYMBOL_VALUE3(EF,A0,99)
+#define SYMBOL_INFO            _SYMBOL_VALUE3(EF,A0,9A)
+#define SYMBOL_WARNING         _SYMBOL_VALUE3(EF,A0,9B)
+#define SYMBOL_SHUFFLE         _SYMBOL_VALUE3(EF,A0,9C)
+#define SYMBOL_UP              _SYMBOL_VALUE3(EF,A0,9D)
+#define SYMBOL_DOWN            _SYMBOL_VALUE3(EF,A0,9E)
+#define SYMBOL_BRIGHTNESS      _SYMBOL_VALUE3(EF,A0,9F)
+#define SYMBOL_DIRECTORY       _SYMBOL_VALUE3(EF,A0,A0)
+#define SYMBOL_UPLOAD          _SYMBOL_VALUE3(EF,A0,A1)
+#define SYMBOL_USB             _SYMBOL_VALUE3(EF,A0,A2)
+#define SYMBOL_TOOLS           _SYMBOL_VALUE3(EF,A0,A3)
+#define SYMBOL_COPY            _SYMBOL_VALUE3(EF,A0,A4)
+#define SYMBOL_SAVE            _SYMBOL_VALUE3(EF,A0,A5)
+#define SYMBOL_CHARGE          _SYMBOL_VALUE3(EF,A0,A6)
+#define SYMBOL_HINT            _SYMBOL_VALUE3(EF,A0,A7)
+#define SYMBOL_KEYBOARD        _SYMBOL_VALUE3(EF,A0,A8)
+#define SYMBOL_GPS             _SYMBOL_VALUE3(EF,A0,A9)
+#define SYMBOL_FILE            _SYMBOL_VALUE3(EF,A0,AA)
+#define SYMBOL_CAMERA          _SYMBOL_VALUE3(EF,A0,AB)
+#define SYMBOL_BATTERY_FULL    _SYMBOL_VALUE3(EF,A0,AC)
+#define SYMBOL_BATTERY_3       _SYMBOL_VALUE3(EF,A0,AD)
+#define SYMBOL_BATTERY_2       _SYMBOL_VALUE3(EF,A0,AE)
+#define SYMBOL_BATTERY_1       _SYMBOL_VALUE3(EF,A0,AF)
+#define SYMBOL_BATTERY_EMPTY   _SYMBOL_VALUE3(EF,A0,B0)
+#define SYMBOL_SHRK            _SYMBOL_VALUE3(EF,A0,B1)
+#define LV_SYMBOL_GLYPH_LAST   0xF831
+#define SYMBOL_DUMMY           _SYMBOL_VALUE3(EF,A3,BF)       /*Invalid symbol at (U+F831). If written before a string then `lv_img` will show it as a label*/
+#endif
+
+#define _SYMBOL_VALUE1(x) (0x ## x)
+#define _SYMBOL_VALUE3(x, y, z) (0x ## z ## y ## x)
+#define _SYMBOL_NUMSTR(sym) LV_ ## sym ## _NUMSTR = sym
+
+enum
+{
+    _SYMBOL_NUMSTR(SYMBOL_DOT),
+    _SYMBOL_NUMSTR(SYMBOL_CLOCK),
+    _SYMBOL_NUMSTR(SYMBOL_LIST),
+    _SYMBOL_NUMSTR(SYMBOL_OK),
+    _SYMBOL_NUMSTR(SYMBOL_CLOSE),
+    _SYMBOL_NUMSTR(SYMBOL_POWER),
+    _SYMBOL_NUMSTR(SYMBOL_SETTINGS),
+    _SYMBOL_NUMSTR(SYMBOL_TRASH),
+    _SYMBOL_NUMSTR(SYMBOL_HOME),
+    _SYMBOL_NUMSTR(SYMBOL_DOWNLOAD),
+    _SYMBOL_NUMSTR(SYMBOL_DRIVE),
+    _SYMBOL_NUMSTR(SYMBOL_REFRESH),
+    _SYMBOL_NUMSTR(SYMBOL_REBOOT),
+    _SYMBOL_NUMSTR(SYMBOL_CHIP),
+    _SYMBOL_NUMSTR(SYMBOL_SD),
+    _SYMBOL_NUMSTR(SYMBOL_CIRCUIT),
+    _SYMBOL_NUMSTR(SYMBOL_EDIT),
+    _SYMBOL_NUMSTR(SYMBOL_FILE_ALT),
+    _SYMBOL_NUMSTR(SYMBOL_FILE_CODE),
+    _SYMBOL_NUMSTR(SYMBOL_FILE_ARC),
+    _SYMBOL_NUMSTR(SYMBOL_TEMPERATURE),
+    _SYMBOL_NUMSTR(SYMBOL_MODULES),
+    _SYMBOL_NUMSTR(SYMBOL_MODULES_ALT),
+    _SYMBOL_NUMSTR(SYMBOL_LEFT),
+    _SYMBOL_NUMSTR(SYMBOL_RIGHT),
+    _SYMBOL_NUMSTR(SYMBOL_KEY),
+    _SYMBOL_NUMSTR(SYMBOL_INFO),
+    _SYMBOL_NUMSTR(SYMBOL_WARNING),
+    _SYMBOL_NUMSTR(SYMBOL_SHUFFLE),
+    _SYMBOL_NUMSTR(SYMBOL_UP),
+    _SYMBOL_NUMSTR(SYMBOL_DOWN),
+    _SYMBOL_NUMSTR(SYMBOL_BRIGHTNESS),
+    _SYMBOL_NUMSTR(SYMBOL_DIRECTORY),
+    _SYMBOL_NUMSTR(SYMBOL_UPLOAD),
+    _SYMBOL_NUMSTR(SYMBOL_USB),
+    _SYMBOL_NUMSTR(SYMBOL_TOOLS),
+    _SYMBOL_NUMSTR(SYMBOL_COPY),
+    _SYMBOL_NUMSTR(SYMBOL_SAVE),
+    _SYMBOL_NUMSTR(SYMBOL_CHARGE),
+    _SYMBOL_NUMSTR(SYMBOL_HINT),
+    _SYMBOL_NUMSTR(SYMBOL_KEYBOARD),
+    _SYMBOL_NUMSTR(SYMBOL_GPS),
+    _SYMBOL_NUMSTR(SYMBOL_FILE),
+    _SYMBOL_NUMSTR(SYMBOL_CAMERA),
+    _SYMBOL_NUMSTR(SYMBOL_BATTERY_FULL),
+    _SYMBOL_NUMSTR(SYMBOL_BATTERY_3),
+    _SYMBOL_NUMSTR(SYMBOL_BATTERY_2),
+    _SYMBOL_NUMSTR(SYMBOL_BATTERY_1),
+    _SYMBOL_NUMSTR(SYMBOL_BATTERY_EMPTY),
+    _SYMBOL_NUMSTR(SYMBOL_SHRK),
+    _SYMBOL_NUMSTR(SYMBOL_DUMMY),
+};
+
+#undef _SYMBOL_VALUE1
+#undef _SYMBOL_VALUE3
+
+#define _SYMBOL_STR_(x) #x
+#define _SYMBOL_STR(x) _SYMBOL_STR_(x)
+#define _SYMBOL_CHAR(c) \x ## c
+#define _SYMBOL_VALUE1(x) _SYMBOL_STR(_SYMBOL_CHAR(x))
+#define _SYMBOL_VALUE3(x, y, z) _SYMBOL_STR(_SYMBOL_CHAR(x)_SYMBOL_CHAR(y)_SYMBOL_CHAR(z))
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /*LV_SYMBOL_DEF_H*/

bdk/libs/lvgl/lv_misc/lv_task.c

@@ -0,0 +1,332 @@
+/**
+ * @file lv_task.c
+ * An 'lv_task'  is a void (*fp) (void* param) type function which will be called periodically.
+ * A priority (5 levels + disable) can be assigned to lv_tasks.
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stddef.h>
+#include "lv_task.h"
+#include "../lv_hal/lv_hal_tick.h"
+#include "lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#   include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+/*********************
+ *      DEFINES
+ *********************/
+#define IDLE_MEAS_PERIOD    500     /*[ms]*/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bool lv_task_exec(lv_task_t * lv_task_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static bool lv_task_run = false;
+static uint8_t idle_last = 0;
+static bool task_deleted;
+static bool task_created;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Init the lv_task module
+ */
+void lv_task_init(void)
+{
+    lv_ll_init(&LV_GC_ROOT(_lv_task_ll), sizeof(lv_task_t));
+
+    /*Initially enable the lv_task handling*/
+    lv_task_enable(true);
+}
+
+/**
+ * Call it  periodically to handle lv_tasks.
+ */
+LV_ATTRIBUTE_TASK_HANDLER void lv_task_handler(void)
+{
+    LV_LOG_TRACE("lv_task_handler started");
+
+    /*Avoid concurrent running of the task handler*/
+    static bool task_handler_mutex = false;
+    if(task_handler_mutex) return;
+    task_handler_mutex = true;
+
+    static uint32_t idle_period_start = 0;
+    static uint32_t handler_start = 0;
+    static uint32_t busy_time = 0;
+
+    if(lv_task_run == false) return;
+
+    handler_start = lv_tick_get();
+
+    /* Run all task from the highest to the lowest priority
+     * If a lower priority task is executed check task again from the highest priority
+     * but on the priority of executed tasks don't run tasks before the executed*/
+    lv_task_t * task_interrupter = NULL;
+    lv_task_t * next;
+    bool end_flag;
+    do {
+        end_flag = true;
+        task_deleted = false;
+        task_created = false;
+        LV_GC_ROOT(_lv_task_act) = lv_ll_get_head(&LV_GC_ROOT(_lv_task_ll));
+        while(LV_GC_ROOT(_lv_task_act)) {
+            /* The task might be deleted if it runs only once ('once = 1')
+             * So get next element until the current is surely valid*/
+            next = lv_ll_get_next(&LV_GC_ROOT(_lv_task_ll), LV_GC_ROOT(_lv_task_act));
+
+            /*We reach priority of the turned off task. There is nothing more to do.*/
+            if(((lv_task_t *)LV_GC_ROOT(_lv_task_act))->prio == LV_TASK_PRIO_OFF) {
+                break;
+            }
+
+            /*Here is the interrupter task. Don't execute it again.*/
+            if(LV_GC_ROOT(_lv_task_act) == task_interrupter) {
+                task_interrupter = NULL;     /*From this point only task after the interrupter comes, so the interrupter is not interesting anymore*/
+                LV_GC_ROOT(_lv_task_act) = next;
+                continue;                   /*Load the next task*/
+            }
+
+            /*Just try to run the tasks with highest priority.*/
+            if(((lv_task_t *)LV_GC_ROOT(_lv_task_act))->prio == LV_TASK_PRIO_HIGHEST) {
+                lv_task_exec(LV_GC_ROOT(_lv_task_act));
+            }
+            /*Tasks with higher priority then the interrupted shall be run in every case*/
+            else if(task_interrupter) {
+                if(((lv_task_t *)LV_GC_ROOT(_lv_task_act))->prio > task_interrupter->prio) {
+                    if(lv_task_exec(LV_GC_ROOT(_lv_task_act))) {
+                        task_interrupter = LV_GC_ROOT(_lv_task_act);  /*Check all tasks again from the highest priority */
+                        end_flag = false;
+                        break;
+                    }
+                }
+            }
+            /* It is no interrupter task or we already reached it earlier.
+             * Just run the remaining tasks*/
+            else {
+                if(lv_task_exec(LV_GC_ROOT(_lv_task_act))) {
+                    task_interrupter = LV_GC_ROOT(_lv_task_act);  /*Check all tasks again from the highest priority */
+                    end_flag = false;
+                    break;
+                }
+            }
+
+            if(task_deleted) break;     /*If a task was deleted then this or the next item might be corrupted*/
+            if(task_created) break;     /*If a task was deleted then this or the next item might be corrupted*/
+
+            LV_GC_ROOT(_lv_task_act) = next;         /*Load the next task*/
+        }
+    } while(!end_flag);
+
+    busy_time += lv_tick_elaps(handler_start);
+    uint32_t idle_period_time = lv_tick_elaps(idle_period_start);
+    if(idle_period_time >= IDLE_MEAS_PERIOD) {
+
+        idle_last = (uint32_t)((uint32_t)busy_time * 100) / IDLE_MEAS_PERIOD;   /*Calculate the busy percentage*/
+        idle_last = idle_last > 100 ? 0 : 100 - idle_last;                      /*But we need idle time*/
+        busy_time = 0;
+        idle_period_start = lv_tick_get();
+
+
+    }
+
+    task_handler_mutex = false;     /*Release the mutex*/
+
+    LV_LOG_TRACE("lv_task_handler ready");
+}
+
+/**
+ * Create a new lv_task
+ * @param task a function which is the task itself
+ * @param period call period in ms unit
+ * @param prio priority of the task (LV_TASK_PRIO_OFF means the task is stopped)
+ * @param param free parameter
+ * @return pointer to the new task
+ */
+lv_task_t * lv_task_create(void (*task)(void *), uint32_t period, lv_task_prio_t prio, void * param)
+{
+    lv_task_t * new_lv_task = NULL;
+    lv_task_t * tmp;
+
+    /*Create task lists in order of priority from high to low*/
+    tmp = lv_ll_get_head(&LV_GC_ROOT(_lv_task_ll));
+    if(NULL == tmp) {                               /*First task*/
+        new_lv_task = lv_ll_ins_head(&LV_GC_ROOT(_lv_task_ll));
+        lv_mem_assert(new_lv_task);
+        if(new_lv_task == NULL) return NULL;
+    } else {
+        do {
+            if(tmp->prio <= prio) {
+                new_lv_task = lv_ll_ins_prev(&LV_GC_ROOT(_lv_task_ll), tmp);
+                lv_mem_assert(new_lv_task);
+                if(new_lv_task == NULL) return NULL;
+                break;
+            }
+            tmp = lv_ll_get_next(&LV_GC_ROOT(_lv_task_ll), tmp);
+        } while(tmp != NULL);
+
+        if(tmp == NULL) {   /*Only too high priority tasks were found*/
+            new_lv_task = lv_ll_ins_tail(&LV_GC_ROOT(_lv_task_ll));
+            lv_mem_assert(new_lv_task);
+            if(new_lv_task == NULL) return NULL;
+        }
+    }
+
+    new_lv_task->period = period;
+    new_lv_task->task = task;
+    new_lv_task->prio = prio;
+    new_lv_task->param = param;
+    new_lv_task->once = 0;
+    new_lv_task->last_run = lv_tick_get();
+
+    task_created = true;
+
+    return new_lv_task;
+}
+
+/**
+ * Delete a lv_task
+ * @param lv_task_p pointer to task created by lv_task_p
+ */
+void lv_task_del(lv_task_t * lv_task_p)
+{
+    lv_ll_rem(&LV_GC_ROOT(_lv_task_ll), lv_task_p);
+
+    lv_mem_free(lv_task_p);
+
+    if(LV_GC_ROOT(_lv_task_act) == lv_task_p) task_deleted = true;      /*The active task was deleted*/
+}
+
+/**
+ * Set new priority for a lv_task
+ * @param lv_task_p pointer to a lv_task
+ * @param prio the new priority
+ */
+void lv_task_set_prio(lv_task_t * lv_task_p, lv_task_prio_t prio)
+{
+    /*Find the tasks with new priority*/
+    lv_task_t * i;
+    LL_READ(LV_GC_ROOT(_lv_task_ll), i) {
+        if(i->prio <= prio) {
+            if(i != lv_task_p) lv_ll_move_before(&LV_GC_ROOT(_lv_task_ll), lv_task_p, i);
+            break;
+        }
+    }
+
+    /*There was no such a low priority so far then add the node to the tail*/
+    if(i == NULL) {
+        lv_ll_move_before(&LV_GC_ROOT(_lv_task_ll), lv_task_p, NULL);
+    }
+
+
+    lv_task_p->prio = prio;
+}
+
+/**
+ * Set new period for a lv_task
+ * @param lv_task_p pointer to a lv_task
+ * @param period the new period
+ */
+void lv_task_set_period(lv_task_t * lv_task_p, uint32_t period)
+{
+    lv_task_p->period = period;
+}
+
+/**
+ * Make a lv_task ready. It will not wait its period.
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_ready(lv_task_t * lv_task_p)
+{
+    lv_task_p->last_run = lv_tick_get() - lv_task_p->period - 1;
+}
+
+/**
+ * Delete the lv_task after one call
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_once(lv_task_t * lv_task_p)
+{
+    lv_task_p->once = 1;
+}
+
+/**
+ * Reset a lv_task.
+ * It will be called the previously set period milliseconds later.
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_reset(lv_task_t * lv_task_p)
+{
+    lv_task_p->last_run = lv_tick_get();
+}
+
+/**
+ * Enable or disable the whole lv_task handling
+ * @param en: true: lv_task handling is running, false: lv_task handling is suspended
+ */
+void lv_task_enable(bool en)
+{
+    lv_task_run = en;
+}
+
+/**
+ * Get idle percentage
+ * @return the lv_task idle in percentage
+ */
+uint8_t lv_task_get_idle(void)
+{
+    return idle_last;
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Execute task if its the priority is appropriate
+ * @param lv_task_p pointer to lv_task
+ * @return true: execute, false: not executed
+ */
+static bool lv_task_exec(lv_task_t * lv_task_p)
+{
+    bool exec = false;
+
+    /*Execute if at least 'period' time elapsed*/
+    uint32_t elp = lv_tick_elaps(lv_task_p->last_run);
+    if(elp >= lv_task_p->period) {
+        lv_task_p->last_run = lv_tick_get();
+        task_deleted = false;
+        task_created = false;
+        lv_task_p->task(lv_task_p->param);
+
+        /*Delete if it was a one shot lv_task*/
+        if(task_deleted == false) {			/*The task might be deleted by itself as well*/
+        	if(lv_task_p->once != 0) {
+        	    lv_task_del(lv_task_p);
+        	}
+        }
+        exec = true;
+    }
+
+    return exec;
+}
+

bdk/libs/lvgl/lv_misc/lv_task.h

@@ -0,0 +1,149 @@
+/**
+ * @file lv_task.c
+ * An 'lv_task'  is a void (*fp) (void* param) type function which will be called periodically.
+ * A priority (5 levels + disable) can be assigned to lv_tasks.
+ */
+
+#ifndef LV_TASK_H
+#define LV_TASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#include <stdint.h>
+#include "lv_mem.h"
+#include "lv_ll.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifndef LV_ATTRIBUTE_TASK_HANDLER
+#define LV_ATTRIBUTE_TASK_HANDLER
+#endif
+/**********************
+ *      TYPEDEFS
+ **********************/
+/**
+ * Possible priorities for lv_tasks
+ */
+#define LV_TASK_ONESHOT 0
+enum
+{
+    LV_TASK_PRIO_OFF = 0,
+    LV_TASK_PRIO_LOWEST,
+    LV_TASK_PRIO_LOW,
+    LV_TASK_PRIO_MID,
+    LV_TASK_PRIO_HIGH,
+    LV_TASK_PRIO_HIGHEST,
+    LV_TASK_PRIO_NUM,
+};
+typedef uint8_t lv_task_prio_t;
+
+/**
+ * Descriptor of a lv_task
+ */
+typedef struct
+{
+    uint32_t period;
+    uint32_t last_run;
+    void (*task) (void*);
+    void * param;
+    uint8_t prio:3;
+    uint8_t once:1;
+} lv_task_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Init the lv_task module
+ */
+void lv_task_init(void);
+
+/**
+ * Call it  periodically to handle lv_tasks.
+ */
+LV_ATTRIBUTE_TASK_HANDLER void lv_task_handler(void);
+
+/**
+ * Create a new lv_task
+ * @param task a function which is the task itself
+ * @param period call period in ms unit
+ * @param prio priority of the task (LV_TASK_PRIO_OFF means the task is stopped)
+ * @param param free parameter
+ * @return pointer to the new task
+ */
+lv_task_t* lv_task_create(void (*task) (void *), uint32_t period, lv_task_prio_t prio, void * param);
+
+/**
+ * Delete a lv_task
+ * @param lv_task_p pointer to task created by lv_task_p
+ */
+void lv_task_del(lv_task_t* lv_task_p);
+
+/**
+ * Set new priority for a lv_task
+ * @param lv_task_p pointer to a lv_task
+ * @param prio the new priority
+ */
+void lv_task_set_prio(lv_task_t* lv_task_p, lv_task_prio_t prio);
+
+/**
+ * Set new period for a lv_task
+ * @param lv_task_p pointer to a lv_task
+ * @param period the new period
+ */
+void lv_task_set_period(lv_task_t* lv_task_p, uint32_t period);
+
+/**
+ * Make a lv_task ready. It will not wait its period.
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_ready(lv_task_t* lv_task_p);
+
+
+/**
+ * Delete the lv_task after one call
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_once(lv_task_t * lv_task_p);
+
+/**
+ * Reset a lv_task.
+ * It will be called the previously set period milliseconds later.
+ * @param lv_task_p pointer to a lv_task.
+ */
+void lv_task_reset(lv_task_t* lv_task_p);
+
+/**
+ * Enable or disable the whole  lv_task handling
+ * @param en: true: lv_task handling is running, false: lv_task handling is suspended
+ */
+void lv_task_enable(bool en);
+
+/**
+ * Get idle percentage
+ * @return the lv_task idle in percentage
+ */
+uint8_t lv_task_get_idle(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

bdk/libs/lvgl/lv_misc/lv_templ.c

@@ -0,0 +1,36 @@
+/**
+ * @file lv_templ.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

bdk/libs/lvgl/lv_misc/lv_templ.h

@@ -0,0 +1,38 @@
+/**
+ * @file lv_templ.h
+ *
+ */
+
+#ifndef LV_TEMPL_H
+#define LV_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_TEMPL_H*/

bdk/libs/lvgl/lv_misc/lv_txt.c

@@ -0,0 +1,793 @@
+/**
+ * @file lv_text.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_txt.h"
+#include "lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define NO_BREAK_FOUND  UINT32_MAX
+
+#ifndef LV_TXT_LINE_BREAK_LONG_LEN
+#define LV_TXT_LINE_BREAK_LONG_LEN 12 /* If a character is at least this long, will break wherever "prettiest" */
+#endif
+
+#ifndef LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN
+#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3 /* Minimum number of characters of a word to put on a line before a break */
+#endif
+
+#ifndef LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN
+#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 1 /* Minimum number of characters of a word to put on a line after a break */
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bool is_break_char(uint32_t letter);
+
+#if LV_TXT_UTF8
+static uint8_t lv_txt_utf8_size(const char * str);
+static uint32_t lv_txt_unicode_to_utf8(uint32_t letter_uni);
+static uint32_t lv_txt_utf8_conv_wc(uint32_t c);
+static uint32_t lv_txt_utf8_next(const char * txt, uint32_t * i);
+static uint32_t lv_txt_utf8_prev(const char * txt, uint32_t * i_start);
+static uint32_t lv_txt_utf8_get_byte_id(const char * txt, uint32_t utf8_id);
+static uint32_t lv_txt_utf8_get_char_id(const char * txt, uint32_t byte_id);
+static uint32_t lv_txt_utf8_get_length(const char * txt);
+#else
+static uint8_t lv_txt_ascii_size(const char * str);
+static uint32_t lv_txt_unicode_to_ascii(uint32_t letter_uni);
+static uint32_t lv_txt_ascii_conv_wc(uint32_t c);
+static uint32_t lv_txt_ascii_next(const char * txt, uint32_t * i);
+static uint32_t lv_txt_ascii_prev(const char * txt, uint32_t * i_start);
+static uint32_t lv_txt_ascii_get_byte_id(const char * txt, uint32_t utf8_id);
+static uint32_t lv_txt_ascii_get_char_id(const char * txt, uint32_t byte_id);
+static uint32_t lv_txt_ascii_get_length(const char * txt);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+#if LV_TXT_UTF8
+uint8_t (*lv_txt_encoded_size)(const char *) =                  lv_txt_utf8_size;
+uint32_t (*lv_txt_unicode_to_encoded)(uint32_t) =               lv_txt_unicode_to_utf8;
+uint32_t (*lv_txt_encoded_conv_wc)(uint32_t) =                  lv_txt_utf8_conv_wc;
+uint32_t (*lv_txt_encoded_next)(const char *, uint32_t *) =    lv_txt_utf8_next;
+uint32_t (*lv_txt_encoded_prev)(const char *, uint32_t *) =   lv_txt_utf8_prev;
+uint32_t (*lv_txt_encoded_get_byte_id)(const char *, uint32_t) = lv_txt_utf8_get_byte_id;
+uint32_t (*lv_encoded_get_char_id)(const char *, uint32_t) =   lv_txt_utf8_get_char_id;
+uint32_t (*lv_txt_get_encoded_length)(const char *) =          lv_txt_utf8_get_length;
+#else
+uint8_t (*lv_txt_encoded_size)(const char *) =                  lv_txt_ascii_size;
+uint32_t (*lv_txt_unicode_to_encoded)(uint32_t) =               lv_txt_unicode_to_ascii;
+uint32_t (*lv_txt_encoded_conv_wc)(uint32_t) =                  lv_txt_ascii_conv_wc;
+uint32_t (*lv_txt_encoded_next)(const char *, uint32_t *) =    lv_txt_ascii_next;
+uint32_t (*lv_txt_encoded_prev)(const char *, uint32_t *) =   lv_txt_ascii_prev;
+uint32_t (*lv_txt_encoded_get_byte_id)(const char *, uint32_t) = lv_txt_ascii_get_byte_id;
+uint32_t (*lv_encoded_get_char_id)(const char *, uint32_t) =   lv_txt_ascii_get_char_id;
+uint32_t (*lv_txt_get_encoded_length)(const char *) =          lv_txt_ascii_get_length;
+#endif
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Get size of a text
+ * @param size_res pointer to a 'point_t' variable to store the result
+ * @param text pointer to a text
+ * @param font pinter to font of the text
+ * @param letter_space letter space of the text
+ * @param txt.line_space line space of the text
+ * @param flags settings for the text from 'txt_flag_t' enum
+ * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid line breaks
+ */
+void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t * font,
+                     lv_coord_t letter_space, lv_coord_t line_space, lv_coord_t max_width, lv_txt_flag_t flag)
+{
+    size_res->x = 0;
+    size_res->y = 0;
+
+    if(text == NULL) return;
+    if(font == NULL) return;
+
+    if(flag & LV_TXT_FLAG_EXPAND) max_width = LV_COORD_MAX;
+
+    uint32_t line_start = 0;
+    uint32_t new_line_start = 0;
+    lv_coord_t act_line_length;
+    uint8_t letter_height = lv_font_get_height(font);
+
+    /*Calc. the height and longest line*/
+    while(text[line_start] != '\0') {
+        new_line_start += lv_txt_get_next_line(&text[line_start], font, letter_space, max_width, flag);
+        size_res->y += letter_height ;
+        size_res->y += line_space;
+
+        /*Calculate the the longest line*/
+        act_line_length = lv_txt_get_width(&text[line_start], new_line_start - line_start,
+                                           font, letter_space, flag);
+
+        size_res->x = LV_MATH_MAX(act_line_length, size_res->x);
+        line_start = new_line_start;
+    }
+
+    /*Make the text one line taller if the last character is '\n' or '\r'*/
+    if((line_start != 0) && (text[line_start - 1] == '\n' || text[line_start - 1] == '\r')) {
+        size_res->y += letter_height + line_space;
+    }
+
+    /*Correction with the last line space or set the height manually if the text is empty*/
+    if(size_res->y == 0) size_res->y = letter_height;
+    else size_res->y -= line_space;
+
+}
+
+/**
+ * Get the next line of text. Check line length and break chars too.
+ * @param txt a '\0' terminated string
+ * @param font pointer to a font
+ * @param letter_space letter space
+ * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid line breaks
+ * @param flags settings for the text from 'txt_flag_type' enum
+ * @return the index of the first char of the new line (in byte index not letter index. With UTF-8 they are different)
+ */
+uint16_t lv_txt_get_next_line(const char * txt, const lv_font_t * font,
+                              lv_coord_t letter_space, lv_coord_t max_width, lv_txt_flag_t flag)
+{
+    if(txt == NULL) return 0;
+    if(font == NULL) return 0;
+
+    if(flag & LV_TXT_FLAG_EXPAND) max_width = LV_COORD_MAX;
+
+    uint32_t i = 0;
+    lv_coord_t cur_w = 0;
+    lv_coord_t w_at_last_break = 0;
+    uint32_t n_char_since_last_break = 0; /* Used count word length of long words */
+    uint32_t last_break = NO_BREAK_FOUND;
+    lv_txt_cmd_state_t cmd_state = LV_TXT_CMD_STATE_WAIT;
+    uint32_t letter = 0;
+
+    while(txt[i] != '\0') {
+        lv_coord_t letter_width;
+        letter = lv_txt_encoded_next(txt, &i);
+
+        /*Handle the recolor command*/
+        if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
+            if(lv_txt_is_cmd(&cmd_state, letter) != false) {
+                continue;   /*Skip the letter is it is part of a command*/
+            }
+        }
+
+
+        /*Check for new line chars*/
+        if(letter == '\n' || letter == '\r') {
+            uint32_t i_tmp = i;
+            uint32_t letter_next = lv_txt_encoded_next(txt, &i_tmp);
+            if(letter == '\r' &&  letter_next == '\n') i = i_tmp;
+
+            return i;    /*Return with the first letter of the next line*/
+
+        } else { /*Check the actual length*/
+            n_char_since_last_break++;
+            letter_width = lv_font_get_width(font, letter);
+            cur_w += letter_width;
+
+            /* Get the length of the current work and determine best place
+             * to break the line. */
+            if(cur_w > max_width) {
+                if( last_break != NO_BREAK_FOUND ) {
+                    /* Continue searching for next breakable character to see if the next word will fit */
+                    uint32_t n_char_fit = n_char_since_last_break - 1;
+                    if(  n_char_since_last_break <= LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN ) {
+                        i = last_break;
+                    }
+                    else {
+                        uint32_t i_tmp = i;
+                        cur_w -= w_at_last_break + letter_space; /*ignore the first letter_space after the break char */
+                        bool other = true;
+                        while(txt[i_tmp] != '\0') {
+                            letter = lv_txt_encoded_next(txt, &i_tmp);
+
+                            /*Handle the recolor command*/
+                            if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
+                                if(lv_txt_is_cmd(&cmd_state, letter) != false) {
+                                    continue;   /*Skip the letter is it is part of a command*/
+                                }
+                            }
+
+                            /*Check for new line chars*/
+                            if(letter == '\n' || letter == '\r' || is_break_char(letter)) {
+                                if(n_char_since_last_break >= LV_TXT_LINE_BREAK_LONG_LEN) {
+                                    /* Figure out the prettiest place to break */
+                                    uint32_t char_remain;
+                                    lv_txt_encoded_prev(txt, &i);
+                                    for(char_remain=n_char_since_last_break - n_char_fit;
+                                            char_remain < LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN;
+                                            char_remain++) {
+                                        lv_txt_encoded_prev(txt, &i);
+                                    }
+                                }
+                                else{
+                                    i = last_break;
+                                }
+                                other = false;
+                                break;
+                            }
+                            n_char_since_last_break++;
+                            lv_coord_t letter_width2 = lv_font_get_width(font, letter);
+                            cur_w += letter_width2;
+                            if(cur_w > max_width) {
+                                /* Current letter already exceeds, return previous */
+                                lv_txt_encoded_prev(txt, &i);
+                                other = false;
+                                break;
+                            }
+                            if(letter_width2 > 0){
+                                cur_w += letter_space;
+                            }
+                        }
+                        if( other ) {
+                            if(n_char_since_last_break >= LV_TXT_LINE_BREAK_LONG_LEN) {
+                                /* Figure out the prettiest place to break */
+                                uint32_t char_remain;
+                                lv_txt_encoded_prev(txt, &i);
+                                for(char_remain=n_char_since_last_break - n_char_fit;
+                                        char_remain < LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN;
+                                        char_remain++){
+                                    lv_txt_encoded_prev(txt, &i);
+                                }
+                            }
+                            else{
+                                i = last_break;
+                            }
+                        }
+                    }
+                } else {
+                    /* Now this character is out of the area so it will be first character of the next line*/
+                    /* But 'i' already points to the next character (because of lv_txt_utf8_next) step beck one*/
+                    lv_txt_encoded_prev(txt, &i);
+                }
+
+                /* Do not let to return without doing nothing.
+                 * Find at least one character (Avoid infinite loop )*/
+                if(i == 0) lv_txt_encoded_next(txt, &i);
+
+                return i;
+            }
+            /*If this char still can fit to this line then check if
+             * txt can be broken here later */
+            else if(is_break_char(letter)) {
+                last_break = i; /*Save the first char index  after break*/
+                w_at_last_break = cur_w;
+                if(letter_width > 0) {
+                    w_at_last_break += letter_space;
+                }
+                n_char_since_last_break = 0;
+            }
+        }
+
+        if(letter_width > 0) {
+            cur_w += letter_space;
+        }
+    }
+
+    return i;
+}
+
+/**
+ * Give the length of a text with a given font
+ * @param txt a '\0' terminate string
+ * @param length length of 'txt' in byte count and not characters (Á is 1 character but 2 bytes in UTF-8)
+ * @param font pointer to a font
+ * @param letter_space letter space
+ * @param flags settings for the text from 'txt_flag_t' enum
+ * @return length of a char_num long text
+ */
+lv_coord_t lv_txt_get_width(const char * txt, uint16_t length,
+                            const lv_font_t * font, lv_coord_t letter_space, lv_txt_flag_t flag)
+{
+    if(txt == NULL) return 0;
+    if(font == NULL) return 0;
+
+    uint32_t i = 0;
+    lv_coord_t width = 0;
+    lv_txt_cmd_state_t cmd_state = LV_TXT_CMD_STATE_WAIT;
+    uint32_t letter;
+
+    if(length != 0) {
+        while(i< length){
+            letter = lv_txt_encoded_next(txt, &i);
+            if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
+                if(lv_txt_is_cmd(&cmd_state, letter) != false) {
+                    continue;
+                }
+            }
+
+            lv_coord_t char_width = lv_font_get_width(font, letter);
+            if(char_width > 0){
+                width += char_width;
+                width += letter_space;
+            }
+        }
+
+        if(width > 0) {
+            width -= letter_space;  /*Trim the last letter space. Important if the text is center aligned */
+        }
+    }
+
+    return width;
+}
+
+/**
+ * Check next character in a string and decide if the character is part of the command or not
+ * @param state pointer to a txt_cmd_state_t variable which stores the current state of command processing
+ *             (Initied. to TXT_CMD_STATE_WAIT )
+ * @param c the current character
+ * @return true: the character is part of a command and should not be written,
+ *         false: the character should be written
+ */
+bool lv_txt_is_cmd(lv_txt_cmd_state_t * state, uint32_t c)
+{
+    bool ret = false;
+
+    if(c == (uint32_t)LV_TXT_COLOR_CMD[0]) {
+        if(*state == LV_TXT_CMD_STATE_WAIT) { /*Start char*/
+            *state = LV_TXT_CMD_STATE_PAR;
+            ret = true;
+        } else if(*state == LV_TXT_CMD_STATE_PAR) { /*Other start char in parameter is escaped cmd. char */
+            *state = LV_TXT_CMD_STATE_WAIT;
+        } else if(*state == LV_TXT_CMD_STATE_IN) { /*Command end */
+            *state = LV_TXT_CMD_STATE_WAIT;
+            ret = true;
+        }
+    }
+
+    /*Skip the color parameter and wait the space after it*/
+    if(*state == LV_TXT_CMD_STATE_PAR) {
+        if(c == ' ') {
+            *state = LV_TXT_CMD_STATE_IN; /*After the parameter the text is in the command*/
+        }
+        ret = true;
+    }
+
+    return ret;
+}
+
+/**
+ * Insert a string into an other
+ * @param txt_buf the original text (must be big enough for the result text)
+ * @param pos position to insert. Expressed in character index and not byte index (Different in UTF-8)
+ *            0: before the original text, 1: after the first char etc.
+ * @param ins_txt text to insert
+ */
+void lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt)
+{
+    uint32_t old_len = strlen(txt_buf);
+    uint32_t ins_len = strlen(ins_txt);
+    uint32_t new_len = ins_len + old_len;
+#if LV_TXT_UTF8 != 0
+    pos = lv_txt_encoded_get_byte_id(txt_buf, pos);   /*Convert to byte index instead of letter index*/
+#endif
+    /*Copy the second part into the end to make place to text to insert*/
+    uint32_t i;
+    for(i = new_len; i >= pos + ins_len; i--) {
+        txt_buf[i] = txt_buf[i - ins_len];
+    }
+
+    /* Copy the text into the new space*/
+    memcpy(txt_buf + pos, ins_txt, ins_len);
+}
+
+/**
+ * Delete a part of a string
+ * @param txt string to modify
+ * @param pos position where to start the deleting (0: before the first char, 1: after the first char etc.)
+ * @param len number of characters to delete
+ */
+void lv_txt_cut(char * txt, uint32_t pos, uint32_t len)
+{
+
+    uint32_t old_len = strlen(txt);
+#if LV_TXT_UTF8 != 0
+    pos = lv_txt_encoded_get_byte_id(txt, pos);   /*Convert to byte index instead of letter index*/
+    len = lv_txt_encoded_get_byte_id(&txt[pos], len);
+#endif
+
+    /*Copy the second part into the end to make place to text to insert*/
+    uint32_t i;
+    for(i = pos; i <= old_len - len; i++) {
+        txt[i] = txt[i + len];
+    }
+}
+
+
+/*******************************
+ *   UTF-8 ENCODER/DECOER
+ ******************************/
+
+#if LV_TXT_UTF8
+
+/**
+ * Give the size of an UTF-8 coded character
+ * @param str pointer to a character in a string
+ * @return length of the UTF-8 character (1,2,3 or 4). O on invalid code
+ */
+static uint8_t lv_txt_utf8_size(const char * str)
+{
+    if((str[0] & 0x80) == 0) return 1;
+    else if((str[0] & 0xE0) == 0xC0) return 2;
+    else if((str[0] & 0xF0) == 0xE0) return 3;
+    else if((str[0] & 0xF8) == 0xF0) return 4;
+    return 0;
+}
+
+
+/**
+ * Convert an Unicode letter to UTF-8.
+ * @param letter_uni an Unicode letter
+ * @return UTF-8 coded character in Little Endian to be compatible with C chars (e.g. 'Á', 'Ű')
+ */
+static uint32_t lv_txt_unicode_to_utf8(uint32_t letter_uni)
+{
+    if(letter_uni < 128) return letter_uni;
+    uint8_t bytes[4];
+
+    if(letter_uni < 0x0800) {
+        bytes[0] = ((letter_uni >> 6)  & 0x1F) | 0xC0;
+        bytes[1] = ((letter_uni >> 0)  & 0x3F) | 0x80;
+        bytes[2] = 0;
+        bytes[3] = 0;
+    } else if(letter_uni < 0x010000) {
+        bytes[0] = ((letter_uni >> 12) & 0x0F) | 0xE0;
+        bytes[1] = ((letter_uni >> 6)  & 0x3F) | 0x80;
+        bytes[2] = ((letter_uni >> 0)  & 0x3F) | 0x80;
+        bytes[3] = 0;
+    } else if(letter_uni < 0x110000) {
+        bytes[0] = ((letter_uni >> 18) & 0x07) | 0xF0;
+        bytes[1] = ((letter_uni >> 12) & 0x3F) | 0x80;
+        bytes[2] = ((letter_uni >> 6)  & 0x3F) | 0x80;
+        bytes[3] = ((letter_uni >> 0)  & 0x3F) | 0x80;
+    }
+
+    uint32_t * res_p = (uint32_t *)bytes;
+    return *res_p;
+}
+
+/**
+ * Convert a wide character, e.g. 'Á' little endian to be UTF-8 compatible
+ * @param c a wide character or a  Little endian number
+ * @return `c` in big endian
+ */
+static uint32_t lv_txt_utf8_conv_wc(uint32_t c)
+{
+    /*Swap the bytes (UTF-8 is big endian, but the MCUs are little endian)*/
+    if((c & 0x80) != 0) {
+        uint32_t swapped;
+        uint8_t c8[4];
+        memcpy(c8, &c, 4);
+        swapped = (c8[0] << 24) + (c8[1] << 16) + (c8[2] << 8) + (c8[3]);
+        uint8_t i;
+        for(i = 0; i < 4; i++) {
+            if((swapped & 0xFF) == 0) swapped = (swapped >> 8); /*Ignore leading zeros (they were in the end originally)*/
+        }
+        c = swapped;
+    }
+
+    return c;
+}
+
+/**
+ * Decode an UTF-8 character from a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i start byte index in 'txt' where to start.
+ *          After call it will point to the next UTF-8 char in 'txt'.
+ *          NULL to use txt[0] as index
+ * @return the decoded Unicode character or 0 on invalid UTF-8 code
+ */
+static uint32_t lv_txt_utf8_next(const char * txt, uint32_t * i)
+{
+    /* Unicode to UTF-8
+     * 00000000 00000000 00000000 0xxxxxxx -> 0xxxxxxx
+     * 00000000 00000000 00000yyy yyxxxxxx -> 110yyyyy 10xxxxxx
+     * 00000000 00000000 zzzzyyyy yyxxxxxx -> 1110zzzz 10yyyyyy 10xxxxxx
+     * 00000000 000wwwzz zzzzyyyy yyxxxxxx -> 11110www 10zzzzzz 10yyyyyy 10xxxxxx
+     * */
+
+    uint32_t result = 0;
+
+    /*Dummy 'i' pointer is required*/
+    uint32_t i_tmp = 0;
+    if(i == NULL) i = &i_tmp;
+
+    /*Normal ASCII*/
+    if((txt[*i] & 0x80) == 0) {
+        result = txt[*i];
+        (*i)++;
+    }
+    /*Real UTF-8 decode*/
+    else {
+        /*2 bytes UTF-8 code*/
+        if((txt[*i] & 0xE0) == 0xC0) {
+            result = (uint32_t)(txt[*i] & 0x1F) << 6;
+            (*i)++;
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += (txt[*i] & 0x3F);
+            (*i)++;
+        }
+        /*3 bytes UTF-8 code*/
+        else if((txt[*i] & 0xF0) == 0xE0) {
+            result = (uint32_t)(txt[*i] & 0x0F) << 12;
+            (*i)++;
+
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += (uint32_t)(txt[*i] & 0x3F) << 6;
+            (*i)++;
+
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += (txt[*i] & 0x3F);
+            (*i)++;
+        }
+        /*4 bytes UTF-8 code*/
+        else if((txt[*i] & 0xF8) == 0xF0) {
+            result = (uint32_t)(txt[*i] & 0x07) << 18;
+            (*i)++;
+
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += (uint32_t)(txt[*i] & 0x3F) << 12;
+            (*i)++;
+
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += (uint32_t)(txt[*i] & 0x3F) << 6;
+            (*i)++;
+
+            if((txt[*i] & 0xC0) != 0x80) return 0;  /*Invalid UTF-8 code*/
+            result += txt[*i] & 0x3F;
+            (*i)++;
+        } else {
+            (*i)++; /*Not UTF-8 char. Go the next.*/
+        }
+    }
+    return result;
+}
+
+/**
+ * Get previous UTF-8 character form a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i start byte index in 'txt' where to start. After the call it will point to the previous UTF-8 char in 'txt'.
+ * @return the decoded Unicode character or 0 on invalid UTF-8 code
+ */
+static uint32_t lv_txt_utf8_prev(const char * txt, uint32_t * i)
+{
+    uint8_t c_size;
+    uint8_t cnt = 0;
+
+    /*Try to find a !0 long UTF-8 char by stepping one character back*/
+    (*i)--;
+    do {
+        if(cnt >= 4) return 0;      /*No UTF-8 char found before the initial*/
+
+        c_size = lv_txt_encoded_size(&txt[*i]);
+        if(c_size == 0) {
+            if(*i != 0)(*i)--;
+            else return 0;
+        }
+        cnt++;
+    } while(c_size == 0);
+
+    uint32_t i_tmp = *i;
+    uint32_t letter = lv_txt_encoded_next(txt, &i_tmp);   /*Character found, get it*/
+
+    return letter;
+
+}
+
+/**
+ * Convert a character index (in an UTF-8 text) to byte index.
+ * E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param utf8_id character index
+ * @return byte index of the 'utf8_id'th letter
+ */
+static uint32_t lv_txt_utf8_get_byte_id(const char * txt, uint32_t utf8_id)
+{
+    uint32_t i;
+    uint32_t byte_cnt = 0;
+    for(i = 0; i < utf8_id; i++) {
+        byte_cnt += lv_txt_encoded_size(&txt[byte_cnt]);
+    }
+
+    return byte_cnt;
+
+}
+
+
+/**
+ * Convert a byte index (in an UTF-8 text) to character index.
+ * E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param byte_id byte index
+ * @return character index of the letter at 'byte_id'th position
+ */
+static uint32_t lv_txt_utf8_get_char_id(const char * txt, uint32_t byte_id)
+{
+    uint32_t i = 0;
+    uint32_t char_cnt = 0;
+
+    while(i < byte_id) {
+        lv_txt_encoded_next(txt, &i); /*'i' points to the next letter so use the prev. value*/
+        char_cnt++;
+    }
+
+    return char_cnt;
+}
+
+/**
+ * Get the number of characters (and NOT bytes) in a string. Decode it with UTF-8 if enabled.
+ * E.g.: "ÁBC" is 3 characters (but 4 bytes)
+ * @param txt a '\0' terminated char string
+ * @return number of characters
+ */
+static uint32_t lv_txt_utf8_get_length(const char * txt)
+{
+#if LV_TXT_UTF8 == 0
+    return strlen(txt);
+#else
+    uint32_t len = 0;
+    uint32_t i = 0;
+
+    while(txt[i] != '\0') {
+        lv_txt_encoded_next(txt, &i);
+        len++;
+    }
+
+    return len;
+#endif
+}
+
+#else
+/**
+ * Give the size of an UTF-8 coded character
+ * @param str pointer to a character in a string
+ * @return length of the UTF-8 character (1,2,3 or 4). O on invalid code
+ */
+static uint8_t lv_txt_ascii_size(const char * str)
+{
+    return 1;
+}
+
+
+/**
+ * Convert an Unicode letter to UTF-8.
+ * @param letter_uni an Unicode letter
+ * @return UTF-8 coded character in Little Endian to be compatible with C chars (e.g. 'Á', 'Ű')
+ */
+static uint32_t lv_txt_unicode_to_ascii(uint32_t letter_uni)
+{
+    if(letter_uni < 128) return letter_uni;
+    else return ' ';
+}
+
+/**
+ * Convert wide characters to ASCII, however wide characters in ASCII range (e.g. 'A') are ASCII compatible by default.
+ * So this function does nothing just returns with `c`.
+ * @param c a character, e.g. 'A'
+ * @return same as `c`
+ */
+static uint32_t lv_txt_ascii_conv_wc(uint32_t c)
+{
+    return c;
+}
+
+/**
+ * Decode an UTF-8 character from a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i start byte index in 'txt' where to start.
+ *          After call it will point to the next UTF-8 char in 'txt'.
+ *          NULL to use txt[0] as index
+ * @return the decoded Unicode character or 0 on invalid UTF-8 code
+ */
+static uint32_t lv_txt_ascii_next(const char * txt, uint32_t * i)
+{
+    if(i == NULL) return txt[1];    /*Get the next char */
+
+    uint8_t letter = txt[*i] ;
+    (*i)++;
+    return letter;
+}
+
+/**
+ * Get previous UTF-8 character form a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i start byte index in 'txt' where to start. After the call it will point to the previous UTF-8 char in 'txt'.
+ * @return the decoded Unicode character or 0 on invalid UTF-8 code
+ */
+static uint32_t lv_txt_ascii_prev(const char * txt, uint32_t * i)
+{
+    if(i == NULL) return *(txt - 1);   /*Get the prev. char */
+
+    (*i)--;
+    uint8_t letter = txt[*i] ;
+
+    return letter;
+}
+
+/**
+ * Convert a character index (in an UTF-8 text) to byte index.
+ * E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param utf8_id character index
+ * @return byte index of the 'utf8_id'th letter
+ */
+static uint32_t lv_txt_ascii_get_byte_id(const char * txt, uint32_t utf8_id)
+{
+    return utf8_id;     /*In Non encoded no difference*/
+}
+
+
+/**
+ * Convert a byte index (in an UTF-8 text) to character index.
+ * E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param byte_id byte index
+ * @return character index of the letter at 'byte_id'th position
+ */
+static uint32_t lv_txt_ascii_get_char_id(const char * txt, uint32_t byte_id)
+{
+    return byte_id;     /*In Non encoded no difference*/
+}
+
+/**
+ * Get the number of characters (and NOT bytes) in a string. Decode it with UTF-8 if enabled.
+ * E.g.: "ÁBC" is 3 characters (but 4 bytes)
+ * @param txt a '\0' terminated char string
+ * @return number of characters
+ */
+static uint32_t lv_txt_ascii_get_length(const char * txt)
+{
+    return strlen(txt);
+}
+#endif
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Test if char is break char or not (a text can broken here or not)
+ * @param letter a letter
+ * @return false: 'letter' is not break char
+ */
+static bool is_break_char(uint32_t letter)
+{
+    uint8_t i;
+    bool ret = false;
+
+    /*Compare the letter to TXT_BREAK_CHARS*/
+    for(i = 0; LV_TXT_BREAK_CHARS[i] != '\0'; i++) {
+        if(letter == (uint32_t)LV_TXT_BREAK_CHARS[i]) {
+            ret = true; /*If match then it is break char*/
+            break;
+        }
+    }
+
+    return ret;
+}
+

bdk/libs/lvgl/lv_misc/lv_txt.h

@@ -0,0 +1,197 @@
+/**
+ * @file lv_text.h
+ *
+ */
+
+#ifndef LV_TXT_H
+#define LV_TXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#include "lv_area.h"
+#include "lv_font.h"
+#include "lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_TXT_COLOR_CMD  "#"
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum
+{
+    LV_TXT_FLAG_NONE =     0x00,
+    LV_TXT_FLAG_RECOLOR =  0x01,   /*Enable parsing of recolor command*/
+    LV_TXT_FLAG_EXPAND =   0x02,   /*Ignore width to avoid automatic word wrapping*/
+    LV_TXT_FLAG_CENTER =   0x04,   /*Align the text to the middle*/
+    LV_TXT_FLAG_RIGHT  =   0x08,   /*Align the text to the right*/
+};
+typedef uint8_t lv_txt_flag_t;
+
+enum
+{
+    LV_TXT_CMD_STATE_WAIT,      /*Waiting for command*/
+    LV_TXT_CMD_STATE_PAR,       /*Processing the parameter*/
+    LV_TXT_CMD_STATE_IN,        /*Processing the command*/
+};
+typedef uint8_t lv_txt_cmd_state_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Get size of a text
+ * @param size_res pointer to a 'point_t' variable to store the result
+ * @param text pointer to a text
+ * @param font pinter to font of the text
+ * @param letter_space letter space of the text
+ * @param line_space line space of the text
+ * @param flags settings for the text from 'txt_flag_t' enum
+ * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid line breaks
+ */
+void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t * font,
+                     lv_coord_t letter_space, lv_coord_t line_space, lv_coord_t max_width, lv_txt_flag_t flag);
+
+/**
+ * Get the next line of text. Check line length and break chars too.
+ * @param txt a '\0' terminated string
+ * @param font pointer to a font
+ * @param letter_space letter space
+ * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid line breaks
+ * @param flags settings for the text from 'txt_flag_type' enum
+ * @return the index of the first char of the new line (in byte index not letter index. With UTF-8 they are different)
+ */
+uint16_t lv_txt_get_next_line(const char * txt, const lv_font_t * font,
+                              lv_coord_t letter_space, lv_coord_t max_width, lv_txt_flag_t flag);
+
+/**
+ * Give the length of a text with a given font
+ * @param txt a '\0' terminate string
+ * @param length length of 'txt' in byte count and not characters (Á is 1 character but 2 bytes in UTF-8)
+ * @param font pointer to a font
+ * @param letter_space letter space
+ * @param flags settings for the text from 'txt_flag_t' enum
+ * @return length of a char_num long text
+ */
+lv_coord_t lv_txt_get_width(const char * txt, uint16_t length,
+                            const lv_font_t * font, lv_coord_t letter_space, lv_txt_flag_t flag);
+
+
+/**
+ * Check next character in a string and decide if te character is part of the command or not
+ * @param state pointer to a txt_cmd_state_t variable which stores the current state of command processing
+ * @param c the current character
+ * @return true: the character is part of a command and should not be written,
+ *         false: the character should be written
+ */
+bool lv_txt_is_cmd(lv_txt_cmd_state_t * state, uint32_t c);
+
+/**
+ * Insert a string into an other
+ * @param txt_buf the original text (must be big enough for the result text)
+ * @param pos position to insert (0: before the original text, 1: after the first char etc.)
+ * @param ins_txt text to insert
+ */
+void lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt);
+
+/**
+ * Delete a part of a string
+ * @param txt string to modify
+ * @param pos position where to start the deleting (0: before the first char, 1: after the first char etc.)
+ * @param len number of characters to delete
+ */
+void lv_txt_cut(char * txt, uint32_t pos, uint32_t len);
+
+/***************************************************************
+ *  GLOBAL FUNCTION POINTERS FOR CAHRACTER ENCODING INTERFACE
+ ***************************************************************/
+
+/**
+ * Give the size of an encoded character
+ * @param str pointer to a character in a string
+ * @return length of the encoded character (1,2,3 ...). O in invalid
+ */
+extern uint8_t (*lv_txt_encoded_size)(const char *);
+
+
+/**
+ * Convert an Unicode letter to encoded
+ * @param letter_uni an Unicode letter
+ * @return Encoded character in Little Endian to be compatible with C chars (e.g. 'Á', 'Ü')
+ */
+extern uint32_t (*lv_txt_unicode_to_encoded)(uint32_t );
+
+/**
+ * Convert a wide character, e.g. 'Á' little endian to be compatible with the encoded format.
+ * @param c a wide character
+ * @return `c` in the encoded format
+ */
+extern uint32_t (*lv_txt_encoded_conv_wc) (uint32_t c);
+
+/**
+ * Decode the next encoded character from a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i start index in 'txt' where to start.
+ *                After the call it will point to the next encoded char in 'txt'.
+ *                NULL to use txt[0] as index
+ * @return the decoded Unicode character or 0 on invalid data code
+ */
+extern uint32_t (*lv_txt_encoded_next)(const char *, uint32_t * );
+
+/**
+ * Get the previous encoded character form a string.
+ * @param txt pointer to '\0' terminated string
+ * @param i_start index in 'txt' where to start. After the call it will point to the previous encoded char in 'txt'.
+ * @return the decoded Unicode character or 0 on invalid data
+ */
+extern uint32_t (*lv_txt_encoded_prev)(const char *, uint32_t *);
+
+/**
+ * Convert a letter index (in an the encoded text) to byte index.
+ * E.g. in UTF-8 "AÁRT" index of 'R' is 2 but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param enc_id letter index
+ * @return byte index of the 'enc_id'th letter
+ */
+extern uint32_t (*lv_txt_encoded_get_byte_id)(const char *, uint32_t);
+
+/**
+ * Convert a byte index (in an encoded text) to character index.
+ * E.g. in UTF-8 "AÁRT" index of 'R' is 2 but start at byte 3 because 'Á' is 2 bytes long
+ * @param txt a '\0' terminated UTF-8 string
+ * @param byte_id byte index
+ * @return character index of the letter at 'byte_id'th position
+ */
+extern uint32_t (*lv_encoded_get_char_id)(const char *, uint32_t);
+
+/**
+ * Get the number of characters (and NOT bytes) in a string.
+ * E.g. in UTF-8 "ÁBC" is 3 characters (but 4 bytes)
+ * @param txt a '\0' terminated char string
+ * @return number of characters
+ */
+extern uint32_t (*lv_txt_get_encoded_length)(const char *);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*USE_TXT*/

bdk/libs/lvgl/lv_misc/lv_ufs.c

@@ -0,0 +1,516 @@
+/**
+ * @file lv_ufs.c
+ * Implementation of RAM file system which do NOT support directories.
+ * The API is compatible with the lv_fs_int module.
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_ufs.h"
+#if USE_LV_FILESYSTEM
+
+#include "lv_ll.h"
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include "lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#   include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_ufs_ent_t * lv_ufs_ent_get(const char * fn);
+static lv_ufs_ent_t * lv_ufs_ent_new(const char * fn);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static bool inited = false;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Create a driver for ufs and initialize it.
+ */
+void lv_ufs_init(void)
+{
+    lv_ll_init(&LV_GC_ROOT(_lv_file_ll), sizeof(lv_ufs_ent_t));
+
+    lv_fs_drv_t ufs_drv;
+    memset(&ufs_drv, 0, sizeof(lv_fs_drv_t));    /*Initialization*/
+
+    ufs_drv.file_size = sizeof(lv_ufs_file_t);
+    ufs_drv.rddir_size = sizeof(lv_ufs_dir_t);
+    ufs_drv.letter = UFS_LETTER;
+    ufs_drv.ready = lv_ufs_ready;
+
+    ufs_drv.open = lv_ufs_open;
+    ufs_drv.close = lv_ufs_close;
+    ufs_drv.remove = lv_ufs_remove;
+    ufs_drv.read = lv_ufs_read;
+    ufs_drv.write = lv_ufs_write;
+    ufs_drv.seek = lv_ufs_seek;
+    ufs_drv.tell = lv_ufs_tell;
+    ufs_drv.size = lv_ufs_size;
+    ufs_drv.trunc = lv_ufs_trunc;
+    ufs_drv.free = lv_ufs_free;
+
+    ufs_drv.dir_open = lv_ufs_dir_open;
+    ufs_drv.dir_read = lv_ufs_dir_read;
+    ufs_drv.dir_close = lv_ufs_dir_close;
+
+    lv_fs_add_drv(&ufs_drv);
+
+    inited = true;
+}
+
+/**
+ * Give the state of the ufs
+ * @return true if ufs is initialized and can be used else false
+ */
+bool lv_ufs_ready(void)
+{
+    return inited;
+}
+
+/**
+ * Open a file in ufs
+ * @param file_p pointer to a lv_ufs_file_t variable
+ * @param fn name of the file. There are no directories so e.g. "myfile.txt"
+ * @param mode element of 'fs_mode_t' enum or its 'OR' connection (e.g. FS_MODE_WR | FS_MODE_RD)
+ * @return LV_FS_RES_OK: no error, the file is opened
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_open(void * file_p, const char * fn, lv_fs_mode_t mode)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+    lv_ufs_ent_t * ent = lv_ufs_ent_get(fn);
+
+    fp->ent = NULL;
+
+    /*If the file not exists ...*/
+    if(ent == NULL) {
+        if((mode & LV_FS_MODE_WR) != 0) {  /*Create the file if opened for write*/
+            ent = lv_ufs_ent_new(fn);
+            if(ent == NULL) return LV_FS_RES_FULL; /*No space for the new file*/
+        } else {
+            return LV_FS_RES_NOT_EX;       /*Can not read not existing file*/
+        }
+    }
+
+    /*Can not write already opened and const data files*/
+    if((mode & LV_FS_MODE_WR) != 0) {
+        if(ent->oc != 0) return LV_FS_RES_LOCKED;
+        if(ent->const_data != 0) return LV_FS_RES_DENIED;
+    }
+
+    /*No error, the file can be opened*/
+    fp->ent = ent;
+    fp->ar = mode & LV_FS_MODE_RD ? 1 : 0;
+    fp->aw = mode & LV_FS_MODE_WR ? 1 : 0;
+    fp->rwp = 0;
+    ent->oc ++;
+
+    return LV_FS_RES_OK;
+}
+
+
+/**
+ * Create a file with a constant data
+ * @param fn name of the file (directories are not supported)
+ * @param const_p pointer to a constant data
+ * @param len length of the data pointed by 'const_p' in bytes
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_create_const(const char * fn, const void * const_p, uint32_t len)
+{
+    lv_ufs_file_t file;
+    lv_fs_res_t res;
+
+    /*Error if the file already exists*/
+    res = lv_ufs_open(&file, fn, LV_FS_MODE_RD);
+    if(res == LV_FS_RES_OK) {
+        lv_ufs_close(&file);
+        return LV_FS_RES_DENIED;
+    }
+
+    lv_ufs_close(&file);
+
+    res = lv_ufs_open(&file, fn, LV_FS_MODE_WR);
+    if(res != LV_FS_RES_OK) return res;
+
+    lv_ufs_ent_t * ent = file.ent;
+
+    if(ent->data_d != NULL) return LV_FS_RES_DENIED;
+
+    ent->data_d = (void *) const_p;
+    ent->size = len;
+    ent->const_data = 1;
+
+    res = lv_ufs_close(&file);
+    if(res != LV_FS_RES_OK) return res;
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_close(void * file_p)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+
+    if(fp->ent == NULL) return LV_FS_RES_OK;
+
+    /*Decrement the Open counter*/
+    if(fp->ent->oc > 0) {
+        fp->ent->oc--;
+    }
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Remove a file. The file can not be opened.
+ * @param fn '\0' terminated string
+ * @return LV_FS_RES_OK: no error, the file is removed
+ *         LV_FS_RES_DENIED: the file was opened, remove failed
+ */
+lv_fs_res_t lv_ufs_remove(const char * fn)
+{
+    lv_ufs_ent_t * ent = lv_ufs_ent_get(fn);
+    if(ent == NULL) return LV_FS_RES_DENIED;    /*File not exists*/
+
+    /*Can not be deleted is opened*/
+    if(ent->oc != 0) return LV_FS_RES_DENIED;
+
+    lv_ll_rem(&LV_GC_ROOT(_lv_file_ll), ent);
+    lv_mem_free(ent->fn_d);
+    ent->fn_d = NULL;
+    if(ent->const_data == 0) {
+        lv_mem_free(ent->data_d);
+        ent->data_d = NULL;
+    }
+
+    lv_mem_free(ent);
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Read data from an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_read(void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+
+    lv_ufs_ent_t * ent = fp->ent;
+    *br = 0;
+
+    if(ent->data_d == NULL || ent->size == 0) { /*Don't read empty files*/
+        return LV_FS_RES_OK;
+    } else if(fp->ar == 0) {    /*The file is not opened for read*/
+        return LV_FS_RES_DENIED;
+    }
+
+    /*No error, read the file*/
+    if(fp->rwp + btr > ent->size) {  /*Check too much bytes read*/
+        *br =  ent->size - fp->rwp;
+    } else {
+        *br = btr;
+    }
+
+    /*Read the data*/
+    uint8_t * data8_p;
+    if(ent->const_data == 0) {
+        data8_p = (uint8_t *) ent->data_d;
+    } else {
+        data8_p = ent->data_d;
+    }
+
+    data8_p += fp->rwp;
+    memcpy(buf, data8_p, *br);
+
+    fp->rwp += *br; /*Refresh the read write pointer*/
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Write data to an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open)
+ * @param buf pointer to a memory block which content will be written
+ * @param btw the number Bytes To Write
+ * @param bw The real number of written bytes (Byte Written)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_write(void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+    *bw = 0;
+
+    if(fp->aw == 0) return LV_FS_RES_DENIED; /*Not opened for write*/
+
+    lv_ufs_ent_t * ent = fp->ent;
+
+    /*Reallocate data array if it necessary*/
+    uint32_t new_size = fp->rwp + btw;
+    if(new_size > ent->size) {
+        uint8_t * new_data = lv_mem_realloc(ent->data_d, new_size);
+        lv_mem_assert(new_data);
+        if(new_data == NULL) return LV_FS_RES_FULL; /*Cannot allocate the new memory*/
+
+        ent->data_d = new_data;
+        ent->size = new_size;
+    }
+
+    /*Write the file*/
+    uint8_t * data8_p = (uint8_t *) ent->data_d;
+    data8_p += fp->rwp;
+    memcpy(data8_p, buf, btw);
+    *bw = btw;
+    fp->rwp += *bw;
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_seek(void * file_p, uint32_t pos)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+    lv_ufs_ent_t * ent = fp->ent;
+
+    /*Simply move the rwp before EOF*/
+    if(pos < ent->size) {
+        fp->rwp = pos;
+    } else { /*Expand the file size*/
+        if(fp->aw == 0) return LV_FS_RES_DENIED;       /*Not opened for write*/
+
+        uint8_t * new_data = lv_mem_realloc(ent->data_d, pos);
+        lv_mem_assert(new_data);
+        if(new_data == NULL) return LV_FS_RES_FULL; /*Out of memory*/
+
+        ent->data_d = new_data;
+        ent->size = pos;
+        fp->rwp = pos;
+    }
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_tell(void * file_p, uint32_t * pos_p)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+
+    *pos_p = fp->rwp;
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Truncate the file size to the current position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_trunc(void * file_p)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+    lv_ufs_ent_t * ent = fp->ent;
+
+    if(fp->aw == 0) return LV_FS_RES_DENIED; /*Not opened for write*/
+
+    void * new_data = lv_mem_realloc(ent->data_d, fp->rwp);
+    lv_mem_assert(new_data);
+    if(new_data == NULL) return LV_FS_RES_FULL; /*Out of memory*/
+
+    ent->data_d = new_data;
+    ent->size = fp->rwp;
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the size of the file in bytes
+ * @param file_p file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param size_p pointer to store the size
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_size(void * file_p, uint32_t * size_p)
+{
+    lv_ufs_file_t * fp = file_p;    /*Convert type*/
+    lv_ufs_ent_t * ent = fp->ent;
+
+    *size_p = ent->size;
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Initialize a lv_ufs_read_dir_t variable to directory reading
+ * @param rddir_p pointer to a 'ufs_dir_t' variable
+ * @param path uFS doesn't support folders so it has to be ""
+ * @return LV_FS_RES_OK or any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_open(void * rddir_p, const char * path)
+{
+    lv_ufs_dir_t * lv_ufs_rddir_p = rddir_p;
+
+    lv_ufs_rddir_p->last_ent = NULL;
+
+    if(path[0] != '\0') return LV_FS_RES_NOT_EX;       /*Must be "" */
+    else return LV_FS_RES_OK;
+}
+
+/**
+ * Read the next file name
+ * @param dir_p pointer to an initialized 'ufs_dir_t' variable
+ * @param fn pointer to buffer to sore the file name
+ * @return LV_FS_RES_OK or any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_read(void * dir_p, char * fn)
+{
+    lv_ufs_dir_t * ufs_dir_p = dir_p;
+
+    if(ufs_dir_p->last_ent == NULL) {
+        ufs_dir_p->last_ent = lv_ll_get_head(&LV_GC_ROOT(_lv_file_ll));
+    } else {
+        ufs_dir_p->last_ent = lv_ll_get_next(&LV_GC_ROOT(_lv_file_ll), ufs_dir_p->last_ent);
+    }
+
+    if(ufs_dir_p->last_ent != NULL) {
+        strcpy(fn, ufs_dir_p->last_ent->fn_d);
+    } else {
+        fn[0] = '\0';
+    }
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close the directory reading
+ * @param rddir_p pointer to an initialized 'ufs_dir_t' variable
+ * @return LV_FS_RES_OK or any error from lv__fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_close(void * rddir_p)
+{
+    (void)rddir_p;
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the size of a drive
+ * @param total_p pointer to store the total size [kB]
+ * @param free_p pointer to store the free site [kB]
+ * @return LV_FS_RES_OK or any error from 'lv_fs_res_t'
+ */
+lv_fs_res_t lv_ufs_free(uint32_t * total_p, uint32_t * free_p)
+{
+
+#if LV_MEM_CUSTOM == 0
+    lv_mem_monitor_t mon;
+
+    lv_mem_monitor(&mon);
+    *total_p = LV_MEM_SIZE >> 10;    /*Convert bytes to kB*/
+    *free_p = mon.free_size >> 10;
+#else
+    *free_p = 0;
+#endif
+    return LV_FS_RES_OK;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Gives the lv_ufs_entry from a filename
+ * @param fn filename ('\0' terminated string)
+ * @return pointer to the dynamically allocated entry with 'fn' filename.
+ *         NULL if no entry found with that name.
+ */
+static lv_ufs_ent_t * lv_ufs_ent_get(const char * fn)
+{
+    lv_ufs_ent_t * fp;
+
+    LL_READ(LV_GC_ROOT(_lv_file_ll), fp) {
+        if(strcmp(fp->fn_d, fn) == 0) {
+            return fp;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Create a new entry with 'fn' filename
+ * @param fn filename ('\0' terminated string)
+ * @return pointer to the dynamically allocated new entry.
+ *         NULL if no space for the entry.
+ */
+static lv_ufs_ent_t * lv_ufs_ent_new(const char * fn)
+{
+    lv_ufs_ent_t * new_ent = NULL;
+    new_ent = lv_ll_ins_head(&LV_GC_ROOT(_lv_file_ll));                 /*Create a new file*/
+    lv_mem_assert(new_ent);
+    if(new_ent == NULL) return NULL;
+
+    new_ent->fn_d = lv_mem_alloc(strlen(fn)  + 1); /*Save the name*/
+    lv_mem_assert(new_ent->fn_d);
+    if(new_ent->fn_d == NULL) return NULL;
+
+    strcpy(new_ent->fn_d, fn);
+    new_ent->data_d = NULL;
+    new_ent->size = 0;
+    new_ent->oc = 0;
+    new_ent->const_data = 0;
+
+    return new_ent;
+}
+
+#endif /*USE_LV_FILESYSTEM*/
+

bdk/libs/lvgl/lv_misc/lv_ufs.h

@@ -0,0 +1,213 @@
+/**
+ * @file lv_ufs.h
+ * Implementation of RAM file system which do NOT support directories.
+ * The API is compatible with the lv_fs_int module.
+ */
+
+#ifndef LV_UFS_H
+#define LV_UFS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
+#if USE_LV_FILESYSTEM
+
+#include "lv_fs.h"
+#include "lv_mem.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define UFS_LETTER 'U'
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+/*Description of a file entry */
+typedef struct
+{
+    char * fn_d;
+    void * data_d;
+    uint32_t size;  /*Data length in bytes*/
+    uint16_t oc;    /*Open Count*/
+    uint8_t const_data :1;
+} lv_ufs_ent_t;
+
+/*File descriptor, used to handle opening an entry more times simultaneously
+ Contains unique informations about the specific opening*/
+typedef struct
+{
+    lv_ufs_ent_t* ent; /*Pointer to the entry*/
+    uint32_t rwp;   /*Read Write Pointer*/
+    uint8_t ar :1;  /*1: Access for read is enabled */
+    uint8_t aw :1;  /*1: Access for write is enabled */
+} lv_ufs_file_t;
+
+/* Read directory descriptor.
+ * It is used to to iterate through the entries in a directory*/
+typedef struct
+{
+    lv_ufs_ent_t * last_ent;
+} lv_ufs_dir_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a driver for ufs and initialize it.
+ */
+void lv_ufs_init(void);
+
+/**
+ * Give the state of the ufs
+ * @return true if ufs is initialized and can be used else false
+ */
+bool lv_ufs_ready(void);
+
+/**
+ * Open a file in ufs
+ * @param file_p pointer to a lv_ufs_file_t variable
+ * @param fn name of the file. There are no directories so e.g. "myfile.txt"
+ * @param mode element of 'fs_mode_t' enum or its 'OR' connection (e.g. FS_MODE_WR | FS_MODE_RD)
+ * @return LV_FS_RES_OK: no error, the file is opened
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_open (void * file_p, const char * fn, lv_fs_mode_t mode);
+
+/**
+ * Create a file with a constant data
+ * @param fn name of the file (directories are not supported)
+ * @param const_p pointer to a constant data
+ * @param len length of the data pointed by 'const_p' in bytes
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_create_const(const char * fn, const void * const_p, uint32_t len);
+
+/**
+ * Close an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_close (void * file_p);
+
+/**
+ * Remove a file. The file can not be opened.
+ * @param fn '\0' terminated string
+ * @return LV_FS_RES_OK: no error, the file is removed
+ *         LV_FS_RES_DENIED: the file was opened, remove failed
+ */
+lv_fs_res_t lv_ufs_remove(const char * fn);
+
+/**
+ * Read data from an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_read (void * file_p, void * buf, uint32_t btr, uint32_t * br);
+
+/**
+ * Write data to an opened file
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open)
+ * @param buf pointer to a memory block which content will be written
+ * @param btw the number Bytes To Write
+ * @param bw The real number of written bytes (Byte Written)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_write (void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_seek (void * file_p, uint32_t pos);
+
+/**
+ * Give the position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_tell (void * file_p, uint32_t * pos_p);
+
+/**
+ * Truncate the file size to the current position of the read write pointer
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_trunc (void * file_p);
+
+/**
+ * Give the size of the file in bytes
+ * @param file_p file_p pointer to an 'ufs_file_t' variable. (opened with lv_ufs_open )
+ * @param size_p pointer to store the size
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_size (void * file_p, uint32_t * size_p);
+
+/**
+ * Initialize a lv_ufs_read_dir_t variable to directory reading
+ * @param rddir_p pointer to a 'ufs_read_dir_t' variable
+ * @param path uFS doesn't support folders so it has to be ""
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_open(void * rddir_p, const char * path);
+
+/**
+ * Read the next file name
+ * @param dir_p pointer to an initialized 'ufs_read_dir_t' variable
+ * @param fn pointer to buffer to sore the file name
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_read(void * dir_p, char * fn);
+
+/**
+ * Close the directory reading
+ * @param rddir_p pointer to an initialized 'ufs_read_dir_t' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+lv_fs_res_t lv_ufs_dir_close(void * rddir_p);
+
+/**
+ * Give the size of a drive
+ * @param total_p pointer to store the total size [kB]
+ * @param free_p pointer to store the free site [kB]
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+lv_fs_res_t lv_ufs_free (uint32_t * total_p, uint32_t * free_p);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*USE_LV_FILESYSTEM*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif