You aint taking this down

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 && defined(DEBUG_UART_PORT)
+        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(DEBUG_UART_PORT, (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