merge dev-5.1

lv_core/lv_group.c

@@ -158,6 +158,8 @@ void lv_group_focus_next(lv_group_t * group)
     if(group->obj_focus){
         (*group->obj_focus)->signal_func(*group->obj_focus, LV_SIGNAL_FOCUS, NULL);
         lv_obj_invalidate(*group->obj_focus);
+
+        if(group->focus_cb) group->focus_cb(group);
     }
 }
 
@@ -184,6 +186,8 @@ void lv_group_focus_prev(lv_group_t * group)
     if(group->obj_focus != NULL){
         (*group->obj_focus)->signal_func(*group->obj_focus, LV_SIGNAL_FOCUS, NULL);
         lv_obj_invalidate(*group->obj_focus);
+
+        if(group->focus_cb) group->focus_cb(group);
     }
 
 }
@@ -212,18 +216,28 @@ void lv_group_send_data(lv_group_t * group, uint32_t c)
     act->signal_func(act, LV_SIGNAL_CONTROLL, &c);
 }
 
-
 /**
  * Set a function for a group which will modify the object's style if it is in focus
  * @param group pointer to a group
- * @param style_cb the style modifier function pointer
+ * @param style_mod_func the style modifier function pointer
  */
-void lv_group_set_style_mod_cb(lv_group_t * group, void (*style_cb)(lv_style_t * style))
+void lv_group_set_style_mod_cb(lv_group_t * group,lv_group_style_mod_func_t style_mod_func)
 {
-    group->style_mod = style_cb;
+    group->style_mod = style_mod_func;
     if(group->obj_focus != NULL) lv_obj_invalidate(*group->obj_focus);
 }
 
+
+/**
+ * Set a function for a group which will be called when a new object is focused
+ * @param group pointer to a group
+ * @param focus_cb the call back function or NULL if unused
+ */
+void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb)
+{
+    group->focus_cb = focus_cb;
+}
+
 /**
  * Modify a style with the set 'style_mod' function. The input style remains unchanged.
  * @param group pointer to group
@@ -253,6 +267,26 @@ lv_obj_t * lv_group_get_focused(lv_group_t * group)
     return *group->obj_focus;
 }
 
+/**
+ * Get a the style modifier function of a group
+ * @param group pointer to a group
+ * @return pointer to the style modifier function
+ */
+lv_group_style_mod_func_t lv_group_get_style_mod_cb(lv_group_t * group)
+{
+    return group->style_mod ;
+}
+
+/**
+ * Get the focus callback function of a group
+ * @param group pointer to a group
+ * @return the call back function or NULL if not set
+ */
+lv_group_focus_cb_t lv_group_get_focus_cb(lv_group_t * group)
+{
+    return group->focus_cb;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -263,6 +297,7 @@ lv_obj_t * lv_group_get_focused(lv_group_t * group)
  */
 static void style_mod_def(lv_style_t * style)
 {
+#if LV_COLOR_DEPTH != 1
     /*Make the style to be a little bit orange*/
     style->body.border.opa = LV_OPA_COVER;
     style->body.border.color = LV_COLOR_ORANGE;
@@ -275,6 +310,13 @@ static void style_mod_def(lv_style_t * style)
     style->body.shadow.color = lv_color_mix(style->body.shadow.color, LV_COLOR_ORANGE, LV_OPA_60);
 
     style->text.color = lv_color_mix(style->text.color, LV_COLOR_ORANGE, LV_OPA_70);
+#else
+    style->body.border.opa = LV_OPA_COVER;
+    style->body.border.color = LV_COLOR_BLACK;
+    style->body.border.width = 3;
+
+#endif
+
 }
 
 #endif /*USE_LV_GROUP != 0*/

lv_core/lv_group.h

@@ -25,22 +25,30 @@ extern "C" {
 #define LV_GROUP_KEY_DOWN           18      /*0x12*/
 #define LV_GROUP_KEY_RIGHT          19      /*0x13*/
 #define LV_GROUP_KEY_LEFT           20      /*0x14*/
-#define LV_GROUP_KEY_ESC            33      /*0x1B*/
+#define LV_GROUP_KEY_ESC            27      /*0x1B*/
 #define LV_GROUP_KEY_ENTER          10      /*0x0A, '\n'*/
 #define LV_GROUP_KEY_NEXT           9       /*0x09, '\t'*/
 #define LV_GROUP_KEY_PREV           11      /*0x0B, '*/
 
+#define LV_GROUP_KEY_ENTER_LONG     14      /*0x0E, Sent by the library if ENTER is long pressed*/
+
 #if USE_LV_GROUP  != 0
 /**********************
  *      TYPEDEFS
  **********************/
+struct _lv_group_t;
+
+typedef void (*lv_group_style_mod_func_t)(lv_style_t *);
+typedef void (*lv_group_focus_cb_t)(struct _lv_group_t *);
+
 typedef struct _lv_group_t
 {
-    lv_ll_t obj_ll;
-    lv_obj_t ** obj_focus;
-    void (*style_mod)(lv_style_t * style);
-    lv_style_t style_tmp;
-    uint8_t frozen:1;
+    lv_ll_t obj_ll;                         /*Linked list to store the objects in the group */
+    lv_obj_t ** obj_focus;                  /*The object in focus*/
+    lv_group_style_mod_func_t style_mod;   /*A function which modifies the style of the focused object*/
+    lv_group_focus_cb_t focus_cb;           /*A function to call when a new object is focused (optional)*/
+    lv_style_t style_tmp;                   /*Stores the modified style of the focused object */
+    uint8_t frozen:1;                       /*1: can't focus to new object*/
 }lv_group_t;
 
 /**********************
@@ -98,13 +106,19 @@ void lv_group_focus_freeze(lv_group_t * group, bool en);
  */
 void lv_group_send_data(lv_group_t * group, uint32_t c);
 
-
 /**
  * Set a function for a group which will modify the object's style if it is in focus
  * @param group pointer to a group
- * @param style_cb the style modifier function pointer
+ * @param style_mod_func the style modifier function pointer
+ */
+void lv_group_set_style_mod_cb(lv_group_t * group,lv_group_style_mod_func_t style_mod_func);
+
+/**
+ * Set a function for a group which will be called when a new object is focused
+ * @param group pointer to a group
+ * @param focus_cb the call back function or NULL if unused
  */
-void lv_group_set_style_mod_cb(lv_group_t * group, void (*style_cb)(lv_style_t * style));
+void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb);
 
 /**
  * Modify a style with the set 'style_mod' function. The input style remains unchanged.
@@ -121,6 +135,20 @@ lv_style_t * lv_group_mod_style(lv_group_t * group, const lv_style_t * style);
  */
 lv_obj_t * lv_group_get_focused(lv_group_t * group);
 
+/**
+ * Get a the style modifier function of a group
+ * @param group pointer to a group
+ * @return pointer to the style modifier function
+ */
+lv_group_style_mod_func_t lv_group_get_style_mod_cb(lv_group_t * group);
+
+/**
+ * Get the focus callback function of a group
+ * @param group pointer to a group
+ * @return the call back function or NULL if not set
+ */
+lv_group_focus_cb_t lv_group_get_focus_cb(lv_group_t * group);
+
 /**********************
  *      MACROS
  **********************/

lv_core/lv_indev.h

@@ -60,40 +60,49 @@ void lv_indev_reset_lpr(lv_indev_t * indev);
 void lv_indev_enable(lv_hal_indev_type_t type, bool enable);
 
 /**
- * Set a cursor for a pointer input device
- * @param indev pointer to an input device (type: 'LV_INDEV_TYPE_POINTER')
+ * Set a cursor for a pointer input device (for LV_INPUT_TYPE_POINTER and LV_INPUT_TYPE_BUTTON)
+ * @param indev pointer to an input device
  * @param cur_obj pointer to an object to be used as cursor
  */
 void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj);
 
 #if USE_LV_GROUP
 /**
- * Set a destination group for a keypad input device
- * @param indev pointer to an input device (type: 'LV_INDEV_TYPE_KEYPAD')
+ * Set a destination group for a keypad input device (for LV_INDEV_TYPE_KEYPAD)
+ * @param indev pointer to an input device
  * @param group point to a group
  */
 void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group);
 #endif
+
+/**
+ * Set the an array of points for LV_INDEV_TYPE_BUTTON.
+ * These points will be assigned to the buttons to press a specific point on the screen
+ * @param indev pointer to an input device
+ * @param group point to a group
+ */
+void lv_indev_set_button_points(lv_indev_t *indev, lv_point_t *points);
+
 /**
- * Get the last point of an input device
+ * Get the last point of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
  * @param indev pointer to an input device
  * @param point pointer to a point to store the result
  */
 void lv_indev_get_point(lv_indev_t * indev, lv_point_t * point);
+
 /**
- * Check if there is dragging with an input device or not
+ * Check if there is dragging with an input device or not (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
  * @param indev pointer to an input device
  * @return true: drag is in progress
  */
 bool lv_indev_is_dragging(lv_indev_t * indev);
 
 /**
- * Get the vector of dragging of an input device
+ * Get the vector of dragging of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
  * @param indev pointer to an input device
  * @param point pointer to a point to store the vector
  */
 void lv_indev_get_vect(lv_indev_t * indev, lv_point_t * point);
-
 /**
  * Get elapsed time since last press
  * @param indev pointer to an input device (NULL to get the overall smallest inactivity)

lv_core/lv_obj.c

@@ -789,6 +789,7 @@ void lv_obj_set_top(lv_obj_t * obj, bool en)
  */
 void lv_obj_set_drag(lv_obj_t * obj, bool en)
 {
+    if(en == true) lv_obj_set_click(obj, true);     /*Drag is useless without enabled clicking*/
     obj->drag = (en == true ? 1 : 0);
 }
 
@@ -1352,6 +1353,34 @@ void * lv_obj_get_ext_attr(lv_obj_t * obj)
    return obj->ext_attr;
 }
 
+/**
+ * Get object's and its ancestors type. Put their name in `type_buf` starting with the current type.
+ * E.g. buf.type[0]="lv_btn", buf.type[1]="lv_cont", buf.type[2]="lv_obj"
+ * @param obj pointer to an object which type should be get
+ * @param buf pointer to an `lv_obj_type_t` buffer to store the types
+ */
+void lv_obj_get_type(lv_obj_t * obj, lv_obj_type_t * buf)
+{
+    lv_obj_type_t tmp;
+
+    memset(buf, 0, sizeof(lv_obj_type_t));
+    memset(&tmp, 0, sizeof(lv_obj_type_t));
+
+    obj->signal_func(obj, LV_SIGNAL_GET_TYPE, &tmp);
+
+    uint8_t cnt;
+    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
+        if(tmp.type[cnt] == NULL) break;
+    }
+
+
+    /*Swap the order. The real type comes first*/
+    uint8_t i;
+    for(i = 0; i < cnt; i++) {
+        buf->type[i] = tmp.type[cnt - 1 - i];
+    }
+}
+
 #ifdef LV_OBJ_FREE_NUM_TYPE
 /**
  * Get the free number
@@ -1376,6 +1405,7 @@ void * lv_obj_get_free_ptr(lv_obj_t * obj)
 }
 #endif
 
+
 #if USE_LV_GROUP
 /**
  * Get the group of the object
@@ -1450,19 +1480,19 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     lv_res_t res = LV_RES_OK;
 
     lv_style_t * style = lv_obj_get_style(obj);
-    switch(sign) {
-        case LV_SIGNAL_CHILD_CHG:
-            /*Return 'invalid' if the child change  signal is not enabled*/
-            if(lv_obj_is_protected(obj, LV_PROTECT_CHILD_CHG) != false) res = LV_RES_INV;
-            break;
-        case LV_SIGNAL_REFR_EXT_SIZE:
-            if(style->body.shadow.width > obj->ext_size) obj->ext_size = style->body.shadow.width;
-            break;
-        case LV_SIGNAL_STYLE_CHG:
-            lv_obj_refresh_ext_size(obj);
-            break;
-        default:
-            break;
+    if(sign == LV_SIGNAL_CHILD_CHG) {
+        /*Return 'invalid' if the child change signal is not enabled*/
+        if(lv_obj_is_protected(obj, LV_PROTECT_CHILD_CHG) != false) res = LV_RES_INV;
+    }
+    else if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
+        if(style->body.shadow.width > obj->ext_size) obj->ext_size = style->body.shadow.width;
+    }
+    else if(sign ==  LV_SIGNAL_STYLE_CHG) {
+        lv_obj_refresh_ext_size(obj);
+    }
+    else if(sign ==  LV_SIGNAL_GET_TYPE) {
+        lv_obj_type_t * buf = param;
+        buf->type[0] = "lv_obj";
     }
 
     return res;

lv_core/lv_obj.h

@@ -28,29 +28,31 @@ extern "C" {
 
 /*Error check of lv_conf.h*/
 #if LV_HOR_RES == 0 || LV_VER_RES == 0
-#error "LV: LV_HOR_RES and LV_VER_RES must be greater then 0"
+#error "LittlevGL: LV_HOR_RES and LV_VER_RES must be greater then 0"
 #endif
 
-#if LV_ANTIALIAS != 0 && LV_ANTIALIAS != 1
-#error "LV: LV_ATIALIAS can be only 0 or 1"
+#if LV_ANTIALIAS > 1
+#error "LittlevGL: LV_ANTIALIAS can be only 0 or 1"
 #endif
 
 #if LV_VDB_SIZE == 0 && LV_ANTIALIAS != 0
-#error "LV: If LV_VDB_SIZE == 0 the antialaissing must be disabled"
+#error "LittlevGL: If LV_VDB_SIZE == 0 the anti-aliasing must be disabled"
 #endif
 
-#if LV_VDB_SIZE != 0 && LV_VDB_SIZE < LV_HOR_RES && LV_ANTIALIAS == 0
-#error "LV: Small Virtual Display Buffer (lv_conf.h: LV_VDB_SIZE >= LV_HOR_RES)"
+#if LV_VDB_SIZE > 0 && LV_VDB_SIZE < LV_HOR_RES
+#error "LittlevGL: Small Virtual Display Buffer (lv_conf.h: LV_VDB_SIZE >= LV_HOR_RES)"
 #endif
 
-#if LV_VDB_SIZE != 0 && LV_VDB_SIZE < 2 *LV_HOR_RES && LV_ANTIALIAS != 0
-#error "LV: Small Virtual Display Buffer (lv_conf.h: LV_VDB_SIZE >= (2 * LV_HOR_RES))"
+#if LV_VDB_SIZE == 0 && USE_LV_REAL_DRAW == 0
+#error "LittlevGL: If LV_VDB_SIZE = 0 Real drawing function are required (lv_conf.h: USE_LV_REAL_DRAW 1)"
 #endif
 
+
 #define LV_ANIM_IN			    0x00	/*Animation to show an object. 'OR' it with lv_anim_builtin_t*/
 #define LV_ANIM_OUT				0x80    /*Animation to hide an object. 'OR' it with lv_anim_builtin_t*/
 #define LV_ANIM_DIR_MASK		0x80	/*ANIM_IN/ANIM_OUT mask*/
 
+#define LV_MAX_ANCESTOR_NUM     8
 /**********************
  *      TYPEDEFS
  **********************/
@@ -80,6 +82,7 @@ typedef enum
     LV_SIGNAL_CORD_CHG,
     LV_SIGNAL_STYLE_CHG,
 	LV_SIGNAL_REFR_EXT_SIZE,
+	LV_SIGNAL_GET_TYPE,
 
 	/*Input device related*/
     LV_SIGNAL_PRESSED,
@@ -116,8 +119,9 @@ typedef struct _lv_obj_t
     void * free_ptr;              /*Application specific pointer (set it freely)*/
 #endif
 
-    void * group_p;             /*Pointer to the group of the object*/
-
+#if USE_LV_GROUP != 0
+    void * group_p;                 /*Pointer to the group of the object*/
+#endif
     /*Attributes and states*/
     uint8_t click     :1;    /*1: Can be pressed by an input device*/
     uint8_t drag      :1;    /*1: Enable the dragging*/
@@ -146,8 +150,15 @@ typedef enum
     LV_PROTECT_PARENT    = 0x02, /*Prevent automatic parent change (e.g. in lv_page)*/
     LV_PROTECT_POS       = 0x04, /*Prevent automatic positioning (e.g. in lv_cont layout)*/
     LV_PROTECT_FOLLOW    = 0x08, /*Prevent the object be followed in automatic ordering (e.g. in lv_cont PRETTY layout)*/
+    LV_PROTECT_PRESS_LOST= 0x10, /*TODO */
 }lv_protect_t;
 
+
+/*Used by `lv_obj_get_type()`. The object's and its ancestor types are stored here*/
+typedef struct {
+    const char * type[LV_MAX_ANCESTOR_NUM];   /*[0]: the actual type, [1]: ancestor, [2] #1's ancestor ... [x]: "lv_obj" */
+}lv_obj_type_t;
+
 typedef enum
 {
     LV_ALIGN_CENTER = 0,
@@ -225,7 +236,6 @@ void lv_obj_clean(lv_obj_t *obj);
  */
 void lv_obj_invalidate(lv_obj_t * obj);
 
-
 /*=====================
  * Setter functions
  *====================*/
@@ -675,6 +685,14 @@ lv_design_func_t lv_obj_get_design_func(lv_obj_t * obj);
  */
 void * lv_obj_get_ext_attr(lv_obj_t * obj);
 
+/**
+ * Get object's and its ancestors type. Put their name in `type_buf` starting with the current type.
+ * E.g. buf.type[0]="lv_btn", buf.type[1]="lv_cont", buf.type[2]="lv_obj"
+ * @param obj pointer to an object which type should be get
+ * @param buf pointer to an `lv_obj_type_t` buffer to store the types
+ */
+void lv_obj_get_type(lv_obj_t * obj, lv_obj_type_t * buf);
+
 #ifdef LV_OBJ_FREE_NUM_TYPE
 /**
  * Get the free number

lv_core/lv_refr.c

@@ -48,7 +48,8 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p);
  **********************/
 static lv_join_t inv_buf[LV_INV_FIFO_SIZE];
 static uint16_t inv_buf_p;
-static void (*monitor_cb)(uint32_t, uint32_t);
+static void (*monitor_cb)(uint32_t, uint32_t); /*Monitor the rendering time*/
+static void (*round_cb)(lv_area_t*);           /*If set then called to modify invalidated areas for special display controllers*/
 static uint32_t px_num;
 
 /**********************
@@ -96,15 +97,8 @@ void lv_inv_area(const lv_area_t * area_p)
     suc = lv_area_union(&com_area, area_p, &scr_area);
 
     /*The area is truncated to the screen*/
-    if(suc != false)
-    {
-#if LV_ANTIALIAS == 1
-    	/*Rounding*/
-    	com_area.x1 = com_area.x1 & (~0x1);
-    	com_area.y1 = com_area.y1 & (~0x1);
-    	com_area.x2 = com_area.x2 | 0x1;
-    	com_area.y2 = com_area.y2 | 0x1;
-#endif
+    if(suc != false) {
+        if(round_cb) round_cb(&com_area);
 
     	/*Save only if this area is not in one of the saved areas*/
     	uint16_t i;
@@ -112,7 +106,6 @@ void lv_inv_area(const lv_area_t * area_p)
     	    if(lv_area_is_in(&com_area, &inv_buf[i].area) != false) return;
     	}
 
-
         /*Save the area*/
     	if(inv_buf_p < LV_INV_FIFO_SIZE) {
             lv_area_copy(&inv_buf[inv_buf_p].area,&com_area);
@@ -136,6 +129,35 @@ void lv_refr_set_monitor_cb(void (*cb)(uint32_t, uint32_t))
     monitor_cb = cb;
 }
 
+/**
+ * Called when an area is invalidated to modify the coordinates of the area.
+ * Special display controllers may require special coordinate rounding
+ * @param cb pointer to the a function which will modify the area
+ */
+void lv_refr_set_round_cb(void(*cb)(lv_area_t*))
+{
+    round_cb = cb;
+}
+
+/**
+ * Get the number of areas in the buffer
+ * @return number of invalid areas
+ */
+uint16_t lv_refr_get_buf_size(void)
+{
+    return inv_buf_p;
+}
+
+/**
+ * Pop (delete) the last 'num' invalidated areas from the buffer
+ * @param num number of areas to delete
+ */
+void lv_refr_pop_from_buf(uint16_t num)
+{
+    if(inv_buf_p < num) inv_buf_p = 0;
+    else inv_buf_p -= num;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -262,10 +284,8 @@ static void lv_refr_area_with_vdb(const lv_area_t * area_p)
     lv_coord_t h = lv_area_get_height(area_p);
     lv_coord_t y2 = area_p->y2 >= LV_VER_RES ? y2 = LV_VER_RES - 1 : area_p->y2;
 
-    uint32_t max_row = (uint32_t) LV_VDB_SIZE / (w << LV_AA);
-    if(max_row > (h << LV_AA)) max_row = (h << LV_AA);
-
-    max_row = max_row >> LV_AA ;
+    uint32_t max_row = (uint32_t) LV_VDB_SIZE / w;
+    if(max_row > h) max_row = h;
 
     /*Always use the full row*/
     uint32_t row;
@@ -312,13 +332,6 @@ static void lv_refr_area_part_vdb(const lv_area_t * area_p)
     lv_area_t start_mask;
     lv_area_union(&start_mask, area_p, &vdb_p->area);
 
-#if LV_ANTIALIAS
-    vdb_p->area.x1 = vdb_p->area.x1 << LV_AA;
-    vdb_p->area.x2 = (vdb_p->area.x2 << LV_AA) + 1;
-    vdb_p->area.y1 = (vdb_p->area.y1 << LV_AA);
-    vdb_p->area.y2 = (vdb_p->area.y2 << LV_AA) + 1;
-#endif
-
     /*Get the most top object which is not covered by others*/
     top_p = lv_refr_get_top_obj(&start_mask, lv_scr_act());
 

lv_core/lv_refr.h

@@ -58,6 +58,24 @@ void lv_inv_area(const lv_area_t * area_p);
  */
 void lv_refr_set_monitor_cb(void (*cb)(uint32_t, uint32_t));
 
+/**
+ * Called when an area is invalidated to modify the coordinates of the area.
+ * Special display controllers may require special coordinate rounding
+ * @param cb pointer to the a function which will modify the area
+ */
+void lv_refr_set_round_cb(void(*cb)(lv_area_t*));
+
+/**
+ * Get the number of areas in the buffer
+ * @return number of invalid areas
+ */
+uint16_t lv_refr_get_buf_size(void);
+
+/**
+ * Pop (delete) the last 'num' invalidated areas from the buffer
+ * @param num number of areas to delete
+ */
+void lv_refr_pop_from_buf(uint16_t num);
 /**********************
  *   STATIC FUNCTIONS
  **********************/

lv_core/lv_style.h

@@ -23,7 +23,6 @@ extern "C" {
  *      DEFINES
  *********************/
 #define LV_RADIUS_CIRCLE  (LV_COORD_MAX)    /*A very big radius to always draw as circle*/
-#define LV_AA             LV_ANTIALIAS  /*Just a shorter form of LV_ANTIALIAS*/
 
 /**********************
  *      TYPEDEFS

lv_core/lv_vdb.c

@@ -119,59 +119,9 @@ void lv_vdb_flush(void)
     if(vdb_state[1] == LV_VDB_STATE_ACTIVE) vdb_state[1] = LV_VDB_STATE_FLUSH;
 #endif
 
-#if LV_ANTIALIAS == 0
+    /*Flush the rendered content to the display*/
 	lv_disp_flush(vdb_act->area.x1, vdb_act->area.y1, vdb_act->area.x2, vdb_act->area.y2, vdb_act->buf);
-#else
-	/* Get the average of 2x2 pixels and put the result back to the VDB
-	 * The reading goes much faster then the write back
-	 * so useful data won't be overwritten
-	 * Example:
-	 * -----------------------------
-	 * in1_buf  |2,2|6,8|      3,7
-	 * in2_buf  |4,4|7,7|      1,2
-	 *          ---------  ==>
-	 * in1_buf  |1,1|1,3|
-	 * in2_buf  |1,1|1,3|
-	 * */
-	lv_coord_t x;
-	lv_coord_t y;
-	lv_coord_t w = lv_area_get_width(&vdb_act->area);
-	lv_color_t * in1_buf = vdb_act->buf;      /*Pointer to the first row*/
-    lv_color_t * in2_buf = vdb_act->buf + w;  /*Pointer to the second row*/
-    lv_color_t * out_buf = vdb_act->buf;      /*Store the result here*/
-	for(y = vdb_act->area.y1; y < vdb_act->area.y2; y += 2) {
-        for(x = vdb_act->area.x1; x < vdb_act->area.x2; x += 2) {
-        
-            /*If the pixels are the same do not calculate the average */
-            if(in1_buf->full == (in1_buf + 1)->full &&
-               in1_buf->full == in2_buf->full &&
-               in1_buf->full == (in2_buf + 1)->full) {
-                out_buf->full = in1_buf->full;
-            } else {
-                /*Get the average of 2x2 red*/
-                out_buf->red = (in1_buf->red + (in1_buf + 1)->red +
-                                in2_buf->red + (in2_buf+ 1)->red) >> 2;
-                /*Get the average of 2x2 green*/
-                out_buf->green = (in1_buf->green + (in1_buf + 1)->green +
-                                  in2_buf->green + (in2_buf + 1)->green) >> 2;
-                /*Get the average of 2x2 blue*/
-                out_buf->blue = (in1_buf->blue + (in1_buf + 1)->blue +
-                                 in2_buf->blue + (in2_buf + 1)->blue) >> 2;
-            }
-            
-			in1_buf += 2; /*Skip the next pixel because it is already used above*/
-            in2_buf += 2;
-			out_buf ++;
-		}
-		/*2 row is ready so go the next 2*/
-		in1_buf += w; /*Skip the next row because it is processed from in2_buf*/
-        in2_buf += w;
-	}
-
-	/* Now the full the VDB is filtered and the result is stored in the first quarter of it
-	 * Write out the filtered map to the display*/
-	lv_disp_flush(vdb_act->area.x1 >> 1, vdb_act->area.y1 >> 1, vdb_act->area.x2 >> 1, vdb_act->area.y2 >> 1, vdb_act->buf);
-#endif
+
 }
 
 /**

lv_draw/lv_draw.h

@@ -19,6 +19,14 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
+/*If image pixels contains alpha we need to know how much byte is a pixel*/
+#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8
+# define LV_IMG_PX_SIZE_ALPHA_BYTE   2
+#elif LV_COLOR_DEPTH == 16
+# define LV_IMG_PX_SIZE_ALPHA_BYTE   3
+#elif LV_COLOR_DEPTH == 24
+# define LV_IMG_PX_SIZE_ALPHA_BYTE   4
+#endif
 
 /**********************
  *      TYPEDEFS
@@ -28,12 +36,39 @@ extern "C" {
  * the result image converter utility*/
 typedef struct
 {
-    uint32_t w:12;        /*Width of the image map*/
-    uint32_t h:12;        /*Height of the image map*/
-    uint32_t transp:1;    /*1: The image contains transparent pixels with LV_COLOR_TRANSP color*/
-    uint32_t cd:3;        /*Color depth (0: reserved, 1: 8 bit, 2: 16 bit or 3: 24 bit, 4-7: reserved)*/
-    uint32_t res :4;      /*Reserved*/
-}lv_img_raw_header_t;
+    union{
+        struct {
+            uint32_t chroma_keyed:1;    /*1: The image contains transparent pixels with LV_COLOR_TRANSP color*/
+            uint32_t alpha_byte  :1;    /*Every pixel is extended with a 8 bit alpha channel*/
+            uint32_t format      :6;    /*See: lv_img_px_format*/
+            uint32_t w:12;              /*Width of the image map*/
+            uint32_t h:12;              /*Height of the image map*/
+        }header;
+        uint8_t src_type;
+    };
+
+    union {
+        const uint8_t * pixel_map;  /*For internal images (c arrays) pointer to the pixels array*/
+        uint8_t first_pixel;        /*For external images (binary) the first byte of the pixels (just for convenient)*/
+    };
+}lv_img_t;
+
+typedef enum {
+    LV_IMG_FORMAT_UNKOWN = 0,
+    LV_IMG_FORMAT_INTERNAL_RAW,       /*'lv_img_t' variable compiled with the code*/
+    LV_IMG_FORMAT_FILE_RAW_RGB332,    /*8 bit*/
+    LV_IMG_FORMAT_FILE_RAW_RGB565,    /*16 bit*/
+    LV_IMG_FORMAT_FILE_RAW_RGB888,    /*24 bit (stored on 32 bit)*/
+}lv_img_format_t;
+
+
+typedef enum {
+    LV_IMG_SRC_VARIABLE,
+    LV_IMG_SRC_FILE,
+    LV_IMG_SRC_SYMBOL,
+    LV_IMG_SRC_UNKNOWN,
+}lv_img_src_t;
+
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -79,8 +114,8 @@ void lv_draw_label(const lv_area_t * cords_p,const lv_area_t * mask_p, const lv_
  * @param mask_p the image will be drawn only in this area
  * @param map_p pointer to a lv_color_t array which contains the pixels of the image
  */
-void lv_draw_img(const lv_area_t * cords_p, const lv_area_t * mask_p,
-                 const lv_style_t * style_p, const char * fn);
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask,
+             const lv_style_t * style, const void * src);
 #endif
 
 /**

lv_draw/lv_draw_rbasic.h

@@ -13,6 +13,9 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
+#include "../../lv_conf.h"
+#if USE_LV_REAL_DRAW != 0
+
 #include "../lv_misc/lv_color.h"
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_font.h"
@@ -55,23 +58,31 @@ void lv_rletter(const lv_point_t * pos_p, const lv_area_t * mask_p,
                 lv_color_t color, lv_opa_t opa);
 
 /**
- * Draw a color map to the display
+ * When the letter is ant-aliased it needs to know the background color
+ * @param bg_color the background color of the currently drawn letter
+ */
+void lv_rletter_set_background(lv_color_t color);
+
+
+/**
+ * Draw a color map to the display (image)
  * @param cords_p coordinates the color map
  * @param mask_p the map will drawn only on this area
  * @param map_p pointer to a lv_color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size (not supported)
- * @param recolor mix the pixels with this color (not supported)
- * @param recolor_opa the intense of recoloring (not supported)
+ * @param opa opacity of the map (ignored, only for compatibility with 'lv_vmap')
+ * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
+ * @param alpha_byte true: extra alpha byte is inserted for every pixel (not supported, only l'v_vmap' can draw it)
+ * @param recolor mix the pixels with this color
+ * @param recolor_opa the intense of recoloring
  */
 void lv_rmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
-             const lv_color_t * map_p, lv_opa_t opa, bool transp, bool upscale,
-			 lv_color_t recolor, lv_opa_t recolor_opa);
+            const uint8_t * map_p, lv_opa_t opa, bool chroma_key, bool alpha_byte,
+            lv_color_t recolor, lv_opa_t recolor_opa);
 /**********************
  *      MACROS
  **********************/
 
+#endif  /*USE_LV_REAL_DRAW*/
 
 #ifdef __cplusplus
 } /* extern "C" */

lv_draw/lv_draw_vbasic.h

@@ -58,19 +58,19 @@ void lv_vletter(const lv_point_t * pos_p, const lv_area_t * mask_p,
                 lv_color_t color, lv_opa_t opa);
 
 /**
- * Draw a color map to the display
+ * Draw a color map to the display (image)
  * @param cords_p coordinates the color map
- * @param mask_p the map will drawn only on this area
+ * @param mask_p the map will drawn only on this area  (truncated to VDB area)
  * @param map_p pointer to a lv_color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size
+ * @param opa opacity of the map
+ * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
+ * @param alpha_byte true: extra alpha byte is inserted for every pixel
  * @param recolor mix the pixels with this color
  * @param recolor_opa the intense of recoloring
  */
 void lv_vmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
-            const lv_color_t * map_p, lv_opa_t opa, bool transp, bool upscale,
-            lv_color_t recolor, lv_opa_t recolor_opa);
+        const uint8_t * map_p, lv_opa_t opa, bool chroma_key, bool alpha_byte,
+        lv_color_t recolor, lv_opa_t recolor_opa);
 
 
 /**

lv_hal/lv_hal_disp.c

@@ -81,7 +81,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t *driver)
         active = node;
         lv_obj_invalidate(lv_scr_act());
     } else {
-        node->next = disp_list;
+        disp_list->next = node;
     }
 
     return node;

lv_hal/lv_hal_indev.c

@@ -46,6 +46,7 @@ void lv_indev_drv_init(lv_indev_drv_t *driver)
 {
     driver->read = NULL;
     driver->type = LV_INDEV_TYPE_NONE;
+    driver->user_data = NULL;
 }
 
 /**
@@ -60,12 +61,14 @@ lv_indev_t * lv_indev_drv_register(lv_indev_drv_t *driver)
     node = lv_mem_alloc(sizeof(lv_indev_t));
     if (!node) return NULL;
 
+    memset(node, 0, sizeof(lv_indev_t));
     memcpy(&node->driver, driver, sizeof(lv_indev_drv_t));
 
     node->next = NULL;
     node->proc.reset_query = 1;
     node->cursor = NULL;
     node->group = NULL;
+    node->btn_points = NULL;
 
     if (indev_list == NULL) {
         indev_list = node;
@@ -107,6 +110,7 @@ bool lv_indev_read(lv_indev_t * indev, lv_indev_data_t *data)
     bool cont = false;
 
     if(indev->driver.read) {
+        data->user_data = indev->driver.user_data;
         cont = indev->driver.read(data);
     } else {
         memset(data, 0, sizeof(lv_indev_data_t));

lv_hal/lv_hal_indev.h

@@ -33,35 +33,40 @@ typedef enum {
     LV_INDEV_TYPE_NONE,        /*Show uninitialized state*/
     LV_INDEV_TYPE_POINTER,     /*Touch pad, mouse, external button*/
     LV_INDEV_TYPE_KEYPAD,      /*Keypad or keyboard*/
+    LV_INDEV_TYPE_BUTTON,      /*External (hardware button) which is assinged to a specific point of the screen*/
 } lv_hal_indev_type_t;
 
 /*States for input devices*/
 typedef enum {
-    LV_INDEV_STATE_REL,
+    LV_INDEV_STATE_REL = 0,
     LV_INDEV_STATE_PR
 }lv_indev_state_t;
 
 /*Data type when an input device is read */
 typedef struct {
     union {
-        lv_point_t point;      /*For INDEV_TYPE_POINTER*/
-        uint32_t key;          /*For INDEV_TYPE_KEYPAD*/
+        lv_point_t point;      /*For LV_INDEV_TYPE_POINTER the currently pressed point*/
+        uint32_t key;          /*For LV_INDEV_TYPE_KEYPAD the currently pressed key*/
+        uint32_t btn;          /*For LV_INDEV_TYPE_BUTTON the currently pressed button*/
     };
-    lv_indev_state_t state; /*LV_INDEV_EVENT_REL or LV_INDEV_EVENT_PR*/
+    lv_indev_state_t state;    /*LV_INDEV_EVENT_REL or LV_INDEV_EVENT_PR*/
+    void *user_data;           /*'lv_indev_drv_t.priv' for this driver*/
 }lv_indev_data_t;
 
 /*Initialized by the user and registered by 'lv_indev_add()'*/
 typedef struct {
-    lv_hal_indev_type_t type;                       /*Input device type*/
+    lv_hal_indev_type_t type;                   /*Input device type*/
     bool (*read)(lv_indev_data_t *data);        /*Function pointer to read data. Return 'true' if there is still data to be read (buffered)*/
+    void *user_data;                            /*Pointer to user defined data, passed in 'lv_indev_data_t' on read*/
 }lv_indev_drv_t;
 
 struct _lv_obj_t;
 
-typedef struct _lv_indev_state_t {
+/*Run time data of input devices*/
+typedef struct _lv_indev_proc_t {
     lv_indev_state_t state;
     union {
-        struct {    /*Pointer data*/
+        struct {    /*Pointer and button data*/
             lv_point_t act_point;
             lv_point_t last_point;
             lv_point_t vect;
@@ -76,6 +81,7 @@ typedef struct _lv_indev_state_t {
         };
         struct {    /*Keypad data*/
             lv_indev_state_t last_state;
+            uint32_t last_key;
         };
     };
 
@@ -92,13 +98,16 @@ typedef struct _lv_indev_state_t {
 struct _lv_obj_t;
 struct _lv_group_t;
 
+/*The main input device descriptor with driver, runtime data ('proc') and some additional information*/
 typedef struct _lv_indev_t {
     lv_indev_drv_t driver;
     lv_indev_proc_t proc;
     uint32_t last_activity_time;
     union {
-        struct _lv_obj_t *cursor;
+        struct _lv_obj_t *cursor;       /*Cursor for LV_INPUT_TYPE_POINTER*/
         struct _lv_group_t *group;      /*Keypad destination group*/
+        lv_point_t * btn_points;      /*Array points assigned to the button ()screen will be pressed here by the buttons*/
+
     };
     struct _lv_indev_t *next;
 } lv_indev_t;

lv_hal/lv_hal_tick.c

@@ -40,7 +40,7 @@ static volatile uint8_t tick_irq_flag;
  * You have to call this function periodically
  * @param tick_period the call period of this function in milliseconds
  */
-inline void LV_ATTRIBUTE_TICK_INC lv_tick_inc(uint32_t tick_period)
+LV_ATTRIBUTE_TICK_INC void lv_tick_inc(uint32_t tick_period)
 {
     tick_irq_flag = 0;
     sys_time += tick_period;

lv_hal/lv_hal_tick.h

@@ -35,7 +35,7 @@ extern "C" {
  * You have to call this function periodically
  * @param tick_period the call period of this function in milliseconds
  */
-void lv_tick_inc(uint32_t tick_period);
+LV_ATTRIBUTE_TICK_INC void lv_tick_inc(uint32_t tick_period);
 
 /**
  * Get the elapsed milliseconds since start up

lv_misc/lv_anim.h

@@ -119,7 +119,7 @@ int32_t lv_anim_path_step(const lv_anim_t *a);
  *      MACROS
  **********************/
 
-#endif /*LV_NO_ANIM == 0*/
+#endif /*USE_LV_ANIMATION == 0*/
 
 #ifdef __cplusplus
 } /* extern "C" */

lv_misc/lv_area.c

@@ -166,45 +166,16 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p)
  */
 bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p)
 {
-    /*Two area are on each other if... */
-    
-    lv_point_t p;
-    /*a2 left-top corner is on a1*/
-    p.x = a2_p->x1;
-    p.y = a2_p->y1;
-    if(lv_area_is_point_on(a1_p, &p)) return true;
-    
-    /*a2 right-top corner is on a1*/
-    p.x = a2_p->x1;
-    p.y = a2_p->y1;
-    if(lv_area_is_point_on(a1_p, &p)) return true;
-    
-    /*a2 left-bottom corner is on a1*/
-    p.x = a2_p->x1;
-    p.y = a2_p->y2;
-    if(lv_area_is_point_on(a1_p, &p)) return true;
-    
-    /*a2 right-bottom corner is on a1*/
-    p.x = a2_p->x2;
-    p.y = a2_p->y2;
-    if(lv_area_is_point_on(a1_p, &p)) return true;
-    
-    /*a2 is horizontally bigger then a1 and covers it*/
-    if((a2_p->x1 <= a1_p->x1 && a2_p->x2 >= a1_p->x2) &&  /*a2 hor. cover a1?*/
-      ((a2_p->y1 <= a1_p->y1 && a2_p->y1 >= a1_p->y2) || /*upper edge is on a1?*/
-       (a2_p->y2 <= a1_p->y1 && a2_p->y2 >= a1_p->y2) ||/* or lower edge is on a1?*/
-       (a2_p->y1 <= a1_p->y1 && a2_p->y2 >= a1_p->y2))) /*or a2 vert bigger then a1*/     
-       return true;
-    
-    /*a2 is vertically bigger then a1 and covers it*/
-    if((a2_p->y1 <= a1_p->y1 && a2_p->y2 >= a1_p->y2) &&  /*a2 vert. cover a1?*/
-      ((a2_p->x1 <= a1_p->x1 && a2_p->x1 >= a1_p->x2) || /*left edge is on a1?*/
-       (a2_p->x2 <= a1_p->x1 && a2_p->x2 >= a1_p->x2) ||/* or right edge is on a1?*/
-       (a2_p->x1 <= a1_p->x1 && a2_p->x2 >= a1_p->x2)))  /*or a2 hor. bigger then a1*/     
-        return true; 
-   
-    /*Else no cover*/
-    return false;
+    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;
+    }
+
 }
 
 /**

lv_misc/lv_color.h

@@ -245,9 +245,17 @@ static inline uint32_t lv_color_to24(lv_color_t color)
 static inline lv_color_t lv_color_mix(lv_color_t c1, lv_color_t c2, uint8_t mix)
 {
     lv_color_t ret;
+#if LV_COLOR_DEPTH != 1
     ret.red =   (uint16_t)((uint16_t) c1.red * mix + (c2.red * (255 - mix))) >> 8;
     ret.green = (uint16_t)((uint16_t) c1.green * mix + (c2.green * (255 - mix))) >> 8;
     ret.blue =  (uint16_t)((uint16_t) c1.blue * mix + (c2.blue * (255 - mix))) >> 8;
+# if LV_COLOR_DEPTH == 24
+    ret.alpha = 0xFF;
+# endif
+#else
+    ret.full = mix > LV_OPA_50 ? c1.full : c2.full;
+#endif
+
     return ret;
 }
 

lv_misc/lv_font.h

@@ -29,15 +29,30 @@ extern "C" {
  *      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 first_ascii;
-    uint32_t last_ascii;
-    uint8_t height_row;
-    const uint8_t * bitmap;
-    const uint32_t * map;
-    const uint8_t * width;
+    uint32_t unicode_first;
+    uint32_t unicode_last;
+    uint8_t h_px;
+    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*/
+    const 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 bpp   :4;                     /*Bit per pixel: 1, 2 or 4*/
 }lv_font_t;
 
 /**********************
@@ -71,21 +86,10 @@ const uint8_t * lv_font_get_bitmap(const lv_font_t * font_p, uint32_t letter);
  */
 static inline uint8_t lv_font_get_height(const lv_font_t * font_p)
 {
-    return font_p->height_row;
+    return font_p->h_px;
 }
 
 /**
- * Get the height of a font. Give the real size on the screen (half size if LV_FONT_ANTIALIAS is enabled)
- * @param font_p pointer to a font
- * @return the height of a font
- */
-static inline uint8_t lv_font_get_height_scale(const lv_font_t * font_p)
-{
-    return (font_p->height_row >> LV_FONT_ANTIALIAS) >> LV_ANTIALIAS;
-}
-
-
-/**
  * Get the width of a letter in a font
  * @param font_p pointer to a font
  * @param letter a letter
@@ -94,78 +98,120 @@ static inline uint8_t lv_font_get_height_scale(const lv_font_t * font_p)
 uint8_t lv_font_get_width(const lv_font_t * font_p, uint32_t letter);
 
 /**
- * Get the width of a letter in a font )Give the real size on the screen (half size if LV_FONT_ANTIALIAS is enabled)
- * @param font_p pointer to a font
- * @param letter a letter
- * @return the width of a letter
+ * 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)
  */
-static inline uint8_t lv_font_get_width_scale(const lv_font_t * font_p, uint32_t letter)
-{
-    return (lv_font_get_width(font_p, letter) >> LV_FONT_ANTIALIAS) >> LV_ANTIALIAS;
-}
+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
+ */
+const 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
+ */
+const 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;
+
+/******************************
+ *  FONT DECLARATION INCLUDES
+ *****************************/
+
+/*10 px */
+#if USE_LV_FONT_DEJAVU_10
+LV_FONT_DECLARE(lv_font_dejavu_10);
+#endif
+
+#if USE_LV_FONT_DEJAVU_10_LATIN_SUP
+LV_FONT_DECLARE(lv_font_dejavu_10_latin_sup);
+#endif
+
+#if USE_LV_FONT_DEJAVU_10_CYRILLIC
+LV_FONT_DECLARE(lv_font_dejavu_10_cyrillic);
+#endif
+
+#if USE_LV_FONT_SYMBOL_10
+LV_FONT_DECLARE(lv_font_symbol_10);
+#endif
+
+/*20 px */
+#if USE_LV_FONT_DEJAVU_20
+LV_FONT_DECLARE(lv_font_dejavu_20);
+#endif
+
+#if USE_LV_FONT_DEJAVU_20_LATIN_SUP
+LV_FONT_DECLARE(lv_font_dejavu_20_latin_sup);
+#endif
+
+#if USE_LV_FONT_DEJAVU_20_CYRILLIC
+LV_FONT_DECLARE(lv_font_dejavu_20_cyrillic);
+#endif
+
+#if USE_LV_FONT_SYMBOL_20
+LV_FONT_DECLARE(lv_font_symbol_20);
+#endif
 
-/***********************
- *   POST INCLUDES
- ***********************/
-/*Add built-in fonts*/
-
-#include "lv_fonts/dejavu_10.h"
-#include "lv_fonts/dejavu_10_sup.h"
-#include "lv_fonts/dejavu_10_latin_ext_a.h"
-#include "lv_fonts/dejavu_10_latin_ext_b.h"
-#include "lv_fonts/dejavu_10_cyrillic.h"
-#include "lv_fonts/symbol_10_basic.h"
-#include "lv_fonts/symbol_10_file.h"
-#include "lv_fonts/symbol_10_feedback.h"
-
-#include "lv_fonts/dejavu_20.h"
-#include "lv_fonts/dejavu_20_sup.h"
-#include "lv_fonts/dejavu_20_latin_ext_a.h"
-#include "lv_fonts/dejavu_20_latin_ext_b.h"
-#include "lv_fonts/dejavu_20_cyrillic.h"
-#include "lv_fonts/symbol_20_basic.h"
-#include "lv_fonts/symbol_20_file.h"
-#include "lv_fonts/symbol_20_feedback.h"
-
-#include "lv_fonts/dejavu_30.h"
-#include "lv_fonts/dejavu_30_sup.h"
-#include "lv_fonts/dejavu_30_latin_ext_a.h"
-#include "lv_fonts/dejavu_30_latin_ext_b.h"
-#include "lv_fonts/dejavu_30_cyrillic.h"
-#include "lv_fonts/symbol_30_basic.h"
-#include "lv_fonts/symbol_30_file.h"
-#include "lv_fonts/symbol_30_feedback.h"
-
-#include "lv_fonts/dejavu_40.h"
-#include "lv_fonts/dejavu_40_sup.h"
-#include "lv_fonts/dejavu_40_latin_ext_a.h"
-#include "lv_fonts/dejavu_40_latin_ext_b.h"
-#include "lv_fonts/dejavu_40_cyrillic.h"
-#include "lv_fonts/symbol_40_basic.h"
-#include "lv_fonts/symbol_40_file.h"
-#include "lv_fonts/symbol_40_feedback.h"
-
-#include "lv_fonts/dejavu_60.h"
-#include "lv_fonts/dejavu_60_sup.h"
-#include "lv_fonts/dejavu_60_latin_ext_a.h"
-#include "lv_fonts/dejavu_60_latin_ext_b.h"
-#include "lv_fonts/dejavu_60_cyrillic.h"
-#include "lv_fonts/symbol_60_basic.h"
-#include "lv_fonts/symbol_60_file.h"
-#include "lv_fonts/symbol_60_feedback.h"
-
-#include "lv_fonts/dejavu_80.h"
-#include "lv_fonts/dejavu_80_sup.h"
-#include "lv_fonts/dejavu_80_latin_ext_a.h"
-#include "lv_fonts/dejavu_80_latin_ext_b.h"
-#include "lv_fonts/dejavu_80_cyrillic.h"
-#include "lv_fonts/symbol_80_basic.h"
-#include "lv_fonts/symbol_80_file.h"
-#include "lv_fonts/symbol_80_feedback.h"
+/*30 px */
+#if USE_LV_FONT_DEJAVU_30
+LV_FONT_DECLARE(lv_font_dejavu_30);
+#endif
+
+#if USE_LV_FONT_DEJAVU_30_LATIN_SUP
+LV_FONT_DECLARE(lv_font_dejavu_30_latin_sup);
+#endif
+
+#if USE_LV_FONT_DEJAVU_30_CYRILLIC
+LV_FONT_DECLARE(lv_font_dejavu_30_cyrillic);
+#endif
+
+#if USE_LV_FONT_SYMBOL_30
+LV_FONT_DECLARE(lv_font_symbol_30);
+#endif
+
+/*40 px */
+#if USE_LV_FONT_DEJAVU_40
+LV_FONT_DECLARE(lv_font_dejavu_40);
+#endif
+
+#if USE_LV_FONT_DEJAVU_40_LATIN_SUP
+LV_FONT_DECLARE(lv_font_dejavu_40_latin_sup);
+#endif
+
+#if USE_LV_FONT_DEJAVU_40_CYRILLIC
+LV_FONT_DECLARE(lv_font_dejavu_40_cyrillic);
+#endif
+
+#if USE_LV_FONT_SYMBOL_40
+LV_FONT_DECLARE(lv_font_symbol_40);
+#endif
 
 #ifdef __cplusplus
 } /* extern "C" */

lv_misc/lv_fonts/dejavu_10.h

-#ifndef DEJAVU_10_H
-#define DEJAVU_10_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_10
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_10;
-
-#endif /*USE_LV_FONT_DEJAVU_10*/
-#endif   /*DEJAVU_10_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_10_cyrillic.h

-#ifndef DEJAVU_10_CYRILLIC_H
-#define DEJAVU_10_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_10_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_10_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_10_CYRILLIC*/
-#endif   /*DEJAVU_10_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_10_latin_ext_a.h

-#ifndef DEJAVU_10_LATIN_EXT_A_H
-#define DEJAVU_10_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_10_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_10_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_10_LATIN_EXT_A*/
-#endif   /*DEJAVU_10_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_10_latin_ext_b.h

-#ifndef DEJAVU_10_LATIN_EXT_B_H
-#define DEJAVU_10_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_10_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_10_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_10_LATIN_EXT_B*/
-#endif   /*DEJAVU_10_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_10_sup.h

-#ifndef DEJAVU_10_SUP_H
-#define DEJAVU_10_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_10_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_10_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_10_SUP*/
-#endif   /*DEJAVU_10_SUP_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_20.h

-#ifndef DEJAVU_20_H
-#define DEJAVU_20_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_20
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_20;
-
-#endif /*USE_LV_FONT_DEJAVU_20*/
-#endif   /*DEJAVU_20_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_20_cyrillic.h

-#ifndef DEJAVU_20_CYRILLIC_H
-#define DEJAVU_20_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_20_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_20_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_20_CYRILLIC*/
-#endif   /*DEJAVU_20_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_20_latin_ext_a.h

-#ifndef DEJAVU_20_LATIN_EXT_A_H
-#define DEJAVU_20_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_20_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_20_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_20_LATIN_EXT_A*/
-#endif   /*DEJAVU_20_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_20_latin_ext_b.h

-#ifndef DEJAVU_20_LATIN_EXT_B_H
-#define DEJAVU_20_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_20_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_20_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_20_LATIN_EXT_B*/
-#endif   /*DEJAVU_20_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_20_sup.h

-#ifndef DEJAVU_20_SUP_H
-#define DEJAVU_20_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_20_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_20_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_20_SUP*/
-#endif   /*DEJAVU_20_SUP_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_30.h

-#ifndef DEJAVU_30_H
-#define DEJAVU_30_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_30
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_30;
-
-#endif /*USE_LV_FONT_DEJAVU_30*/
-#endif   /*DEJAVU_30_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_30_cyrillic.h

-#ifndef DEJAVU_30_CYRILLIC_H
-#define DEJAVU_30_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_30_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_30_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_30_CYRILLIC*/
-#endif   /*DEJAVU_30_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_30_latin_ext_a.h

-#ifndef DEJAVU_30_LATIN_EXT_A_H
-#define DEJAVU_30_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_30_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_30_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_30_LATIN_EXT_A*/
-#endif   /*DEJAVU_30_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_30_latin_ext_b.h

-#ifndef DEJAVU_30_LATIN_EXT_B_H
-#define DEJAVU_30_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_30_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_30_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_30_LATIN_EXT_B*/
-#endif   /*DEJAVU_30_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_30_sup.h

-#ifndef DEJAVU_30_SUP_H
-#define DEJAVU_30_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_30_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_30_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_30_SUP*/
-#endif   /*DEJAVU_30_SUP_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_40.h

-#ifndef DEJAVU_40_H
-#define DEJAVU_40_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_40
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_40;
-
-#endif /*USE_LV_FONT_DEJAVU_40*/
-#endif   /*DEJAVU_40_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_40_cyrillic.h

-#ifndef DEJAVU_40_CYRILLIC_H
-#define DEJAVU_40_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_40_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_40_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_40_CYRILLIC*/
-#endif   /*DEJAVU_40_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_40_latin_ext_a.h

-#ifndef DEJAVU_40_LATIN_EXT_A_H
-#define DEJAVU_40_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_40_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_40_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_40_LATIN_EXT_A*/
-#endif   /*DEJAVU_40_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_40_latin_ext_b.h

-#ifndef DEJAVU_40_LATIN_EXT_B_H
-#define DEJAVU_40_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_40_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_40_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_40_LATIN_EXT_B*/
-#endif   /*DEJAVU_40_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_40_sup.h

-#ifndef DEJAVU_40_SUP_H
-#define DEJAVU_40_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_40_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_40_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_40_SUP*/
-#endif   /*DEJAVU_40_SUP_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_60.h

-#ifndef DEJAVU_60_H
-#define DEJAVU_60_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_60
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_60;
-
-#endif /*USE_LV_FONT_DEJAVU_60*/
-#endif   /*DEJAVU_60_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_60_cyrillic.h

-#ifndef DEJAVU_60_CYRILLIC_H
-#define DEJAVU_60_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_60_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_60_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_60_CYRILLIC*/
-#endif   /*DEJAVU_60_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_60_latin_ext_a.h

-#ifndef DEJAVU_60_LATIN_EXT_A_H
-#define DEJAVU_60_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_60_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_60_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_60_LATIN_EXT_A*/
-#endif   /*DEJAVU_60_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_60_latin_ext_b.h

-#ifndef DEJAVU_60_LATIN_EXT_B_H
-#define DEJAVU_60_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_60_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_60_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_60_LATIN_EXT_B*/
-#endif   /*DEJAVU_60_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_60_sup.h

-#ifndef DEJAVU_60_SUP_H
-#define DEJAVU_60_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_60_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_60_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_60_SUP*/
-#endif   /*DEJAVU_60_SUP_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_80.h

-#ifndef DEJAVU_80_H
-#define DEJAVU_80_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_80
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_80;
-
-#endif /*USE_LV_FONT_DEJAVU_80*/
-#endif   /*DEJAVU_80_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_80_cyrillic.h

-#ifndef DEJAVU_80_CYRILLIC_H
-#define DEJAVU_80_CYRILLIC_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_80_CYRILLIC
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_80_cyrillic;
-
-#endif /*USE_LV_FONT_DEJAVU_80_CYRILLIC*/
-#endif   /*DEJAVU_80_CYRILLIC_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_80_latin_ext_a.h

-#ifndef DEJAVU_80_LATIN_EXT_A_H
-#define DEJAVU_80_LATIN_EXT_A_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_80_LATIN_EXT_A
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_80_latin_ext_a;
-
-#endif /*USE_LV_FONT_DEJAVU_80_LATIN_EXT_A*/
-#endif   /*DEJAVU_80_LATIN_EXT_A_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_80_latin_ext_b.h

-#ifndef DEJAVU_80_LATIN_EXT_B_H
-#define DEJAVU_80_LATIN_EXT_B_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_80_LATIN_EXT_B
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_80_latin_ext_b;
-
-#endif /*USE_LV_FONT_DEJAVU_80_LATIN_EXT_B*/
-#endif   /*DEJAVU_80_LATIN_EXT_B_H*/
\ No newline at end of file

lv_misc/lv_fonts/dejavu_80_sup.h

-#ifndef DEJAVU_80_SUP_H
-#define DEJAVU_80_SUP_H
-
-/*Use UTF-8 encoding in the IDE*/
-
-#include "../../../lv_conf.h"
-#if USE_LV_FONT_DEJAVU_80_SUP
-
-#include <stdint.h>
-#include "../lv_font.h"
-
-extern lv_font_t lv_font_dejavu_80_sup;
-
-#endif /*USE_LV_FONT_DEJAVU_80_SUP*/
-#endif   /*DEJAVU_80_SUP_H*/
\ No newline at end of file