From e55500af5dd4c7b7d4fcf0bcf16086c69ce6ff8a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sun, 28 Jun 2020 13:19:28 +0200
Subject: [PATCH 01/84] scroll: add basic api

---
 src/lv_core/lv_obj.c | 59 ++++++++++++++++++++++++++++++++++++++++++++
 src/lv_core/lv_obj.h |  1 +
 2 files changed, 60 insertions(+)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 91e2f9636..8f454d2c5 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1061,6 +1061,65 @@ void lv_obj_set_auto_realign(lv_obj_t * obj, bool en)
 #endif
 }
 
+/**
+ * Moves all children with horizontally or vertically.
+ * It doesn't take into account any limits so any values are possible
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+{
+    obj->scroll.x += x;
+    obj->scroll.y += y;
+
+    refresh_children_position(obj, x, y);
+}
+/**
+ * Moves all children with horizontally or vertically.
+ * Limits the scroll to the bounding box of the children.
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+    obj->scroll.x += x;
+    obj->scroll.y += y;
+
+    refresh_children_position(obj, x, y);
+}
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+
+}
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ */
+void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
+{
+//    refresh_children_position(obj, x, y);
+}
+
+/**
+ * Scroll the a given y coordinate to the top side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+//    refresh_children_position(obj, x, y);
+}
 
 /**
  * Set the size of an extended clickable area
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index ad438c399..112959fe1 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -198,6 +198,7 @@ typedef struct _lv_obj_t {
     lv_ll_t child_ll;       /**< Linked list to store the children objects*/
 
     lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
+    lv_point_t scroll; /**< The current X/Y scroll offset*/
 
     lv_event_cb_t event_cb; /**< Event callback function */
     lv_signal_cb_t signal_cb; /**< Object type specific signal function*/

From b091b676fe96f35d87ec3c9089e4a151a61b76fc Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 2 Jul 2020 13:04:44 +0200
Subject: [PATCH 02/84] scroll: add animation and elastic scroll

---
 src/lv_core/lv_indev.c | 162 +++++++++++++++++++----------------------
 src/lv_core/lv_obj.c   | 101 ++++++++++++++++++++++++-
 src/lv_core/lv_obj.h   |  10 ++-
 3 files changed, 179 insertions(+), 94 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index a491c0996..4e78de2ca 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1245,15 +1245,20 @@ static void indev_click_focus(lv_indev_proc_t * proc)
  */
 static void indev_drag(lv_indev_proc_t * proc)
 {
-    lv_obj_t * drag_obj    = get_dragged_obj(proc->types.pointer.act_obj);
-    bool drag_just_started = false;
 
-    if(drag_obj == NULL) return;
+    bool scrollable = true;
 
-    if(lv_obj_get_drag(drag_obj) == false) return;
+    /*Get which object to drad/scroll*/
+    lv_obj_t * target_obj = get_dragged_obj(proc->types.pointer.act_obj);
+    if(target_obj == NULL) return;
 
+    lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
 
-    lv_drag_dir_t allowed_dirs = lv_obj_get_drag_dir(drag_obj);
+    bool just_started = false;
+
+    /*Get the coordinates of the object and modify them*/
+    lv_coord_t act_x = lv_obj_get_x(target_obj);
+    lv_coord_t act_y = lv_obj_get_y(target_obj);
 
     /*Count the movement by drag*/
     if(proc->types.pointer.drag_limit_out == 0) {
@@ -1263,15 +1268,15 @@ static void indev_drag(lv_indev_proc_t * proc)
         /*Enough move?*/
         bool hor_en = false;
         bool ver_en = false;
-        if(allowed_dirs == LV_DRAG_DIR_HOR || allowed_dirs == LV_DRAG_DIR_BOTH) {
+        if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
             hor_en = true;
         }
 
-        if(allowed_dirs == LV_DRAG_DIR_VER || allowed_dirs == LV_DRAG_DIR_BOTH) {
+        if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
             ver_en = true;
         }
 
-        if(allowed_dirs == LV_DRAG_DIR_ONE) {
+        if(dirs == LV_DRAG_DIR_ONE) {
             if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
                 hor_en = true;
             }
@@ -1284,102 +1289,77 @@ static void indev_drag(lv_indev_proc_t * proc)
         if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
            (ver_en && LV_MATH_ABS(proc->types.pointer.drag_sum.y) >= indev_act->driver.drag_limit)) {
             proc->types.pointer.drag_limit_out = 1;
-            drag_just_started                   = true;
+            just_started = true;
+            if(dirs == LV_DRAG_DIR_ONE) {
+                proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
+            } else {
+                proc->types.pointer.drag_dir = dirs;
+            }
+
+            /*The was no move due to drag limit. Compensate it now.*/
+            if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
+            if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
+
+            act_x += proc->types.pointer.drag_sum.x;
+            act_y += proc->types.pointer.drag_sum.y;
         }
     }
 
     /*If the drag limit is exceeded handle the dragging*/
     if(proc->types.pointer.drag_limit_out != 0) {
-        /*Set new position if the vector is not zero*/
+        /*Set new position or scroll if the vector is not zero*/
         if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
 
-            lv_coord_t prev_x     = drag_obj->coords.x1;
-            lv_coord_t prev_y     = drag_obj->coords.y1;
-            lv_coord_t prev_par_w = lv_obj_get_width(lv_obj_get_parent(drag_obj));
-            lv_coord_t prev_par_h = lv_obj_get_height(lv_obj_get_parent(drag_obj));
+            lv_coord_t prev_x     = target_obj->coords.x1;
+            lv_coord_t prev_y     = target_obj->coords.y1;
 
-            /*Get the coordinates of the object and modify them*/
-            lv_coord_t act_x = lv_obj_get_x(drag_obj);
-            lv_coord_t act_y = lv_obj_get_y(drag_obj);
-
-            if(allowed_dirs == LV_DRAG_DIR_BOTH) {
-                if(drag_just_started) {
-                    proc->types.pointer.drag_dir = LV_DRAG_DIR_BOTH;
-                    act_x += proc->types.pointer.drag_sum.x;
-                    act_y += proc->types.pointer.drag_sum.y;
-                }
-            }
-            else if(allowed_dirs == LV_DRAG_DIR_HOR) {
-                if(drag_just_started) {
-                    proc->types.pointer.drag_dir = LV_DRAG_DIR_HOR;
-                    proc->types.pointer.drag_sum.y = 0;
-                    act_x += proc->types.pointer.drag_sum.x;
-                }
-            }
-            else if(allowed_dirs == LV_DRAG_DIR_VER) {
-                if(drag_just_started) {
-                    proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
-                    proc->types.pointer.drag_sum.x = 0;
-                    act_y += proc->types.pointer.drag_sum.y;
-                }
-            }
-            else if(allowed_dirs == LV_DRAG_DIR_ONE) {
-                if(drag_just_started) {
-                    if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
-                        proc->types.pointer.drag_dir = LV_DRAG_DIR_HOR;
-                        proc->types.pointer.drag_sum.y = 0;
-                        act_x += proc->types.pointer.drag_sum.x;
-                    }
-                    else {
-                        proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
-                        proc->types.pointer.drag_sum.x = 0;
-                        act_y += proc->types.pointer.drag_sum.y;
-                    }
-                }
-            }
-
-            /*Move the object*/
-            if(allowed_dirs == LV_DRAG_DIR_HOR ||
-               allowed_dirs == LV_DRAG_DIR_BOTH ||
-               (allowed_dirs == LV_DRAG_DIR_ONE &&
-                LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y))) {
-                act_x += proc->types.pointer.vect.x;
-            }
-            if(allowed_dirs == LV_DRAG_DIR_VER ||
-               allowed_dirs == LV_DRAG_DIR_BOTH ||
-               (allowed_dirs == LV_DRAG_DIR_ONE &&
-                LV_MATH_ABS(proc->types.pointer.drag_sum.x) < LV_MATH_ABS(proc->types.pointer.drag_sum.y))) {
-                act_y += proc->types.pointer.vect.y;
-            }
+            /*Move the object. `drag_sum` is zerod out for *disabled direction*/
+            if(proc->types.pointer.drag_sum.x) act_x += proc->types.pointer.vect.x;
+            if(proc->types.pointer.drag_sum.y) act_y += proc->types.pointer.vect.y;
 
             uint16_t inv_buf_size =
                 lv_disp_get_inv_buf_size(indev_act->driver.disp); /*Get the number of currently invalidated areas*/
 
-            lv_obj_set_pos(drag_obj, act_x, act_y);
-            proc->types.pointer.drag_in_prog = 1;
-
-            /*If the object didn't moved then clear the invalidated areas*/
-            if(drag_obj->coords.x1 == prev_x && drag_obj->coords.y1 == prev_y) {
-                /*In a special case if the object is moved on a page and
-                 * the scrollable has fit == true and the object is dragged of the page then
-                 * while its coordinate is not changing only the parent's size is reduced */
-                lv_coord_t act_par_w = lv_obj_get_width(lv_obj_get_parent(drag_obj));
-                lv_coord_t act_par_h = lv_obj_get_height(lv_obj_get_parent(drag_obj));
-                if(act_par_w == prev_par_w && act_par_h == prev_par_h) {
-                    uint16_t new_inv_buf_size = lv_disp_get_inv_buf_size(indev_act->driver.disp);
-                    _lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
+            if(scrollable) {
+                lv_area_t child_box;
+                lv_obj_get_children_box(target_obj, &child_box);
+                lv_coord_t diff_y = proc->types.pointer.vect.y;
+                if(target_obj->scroll.y > 0 && diff_y > 0) {
+                    diff_y = diff_y / 2;
                 }
+                if(child_box.y2 < target_obj->coords.y2 && diff_y < 0) {
+                    diff_y = diff_y / 2;
+                }
+
+                lv_obj_scroll_by(target_obj, 0, diff_y, LV_ANIM_OFF);
+            } else {
+                lv_obj_set_pos(target_obj, act_x, act_y);
             }
 
-            /*Set the drag in progress flag*/
-            /*Send the drag begin signal on first move*/
-            if(drag_just_started) {
-                drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_BEGIN, indev_act);
-                if(indev_reset_check(proc)) return;
-
-                lv_event_send(drag_obj, LV_EVENT_DRAG_BEGIN, NULL);
-                if(indev_reset_check(proc)) return;
-            }
+            proc->types.pointer.drag_in_prog = 1;
+//
+//            /*If the object didn't moved then clear the invalidated areas*/
+//            if(target_obj->coords.x1 == prev_x && target_obj->coords.y1 == prev_y) {
+//                /*In a special case if the object is moved on a page and
+//                 * the scrollable has fit == true and the object is dragged of the page then
+//                 * while its coordinate is not changing only the parent's size is reduced */
+//                lv_coord_t act_par_w = lv_obj_get_width(lv_obj_get_parent(target_obj));
+//                lv_coord_t act_par_h = lv_obj_get_height(lv_obj_get_parent(target_obj));
+//                if(act_par_w == prev_par_w && act_par_h == prev_par_h) {
+//                    uint16_t new_inv_buf_size = lv_disp_get_inv_buf_size(indev_act->driver.disp);
+//                    _lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
+//                }
+//            }
+//
+//            /*Set the drag in progress flag*/
+//            /*Send the drag begin signal on first move*/
+//            if(just_started) {
+//                target_obj->signal_cb(target_obj, LV_SIGNAL_DRAG_BEGIN, indev_act);
+//                if(indev_reset_check(proc)) return;
+//
+//                lv_event_send(target_obj, LV_EVENT_DRAG_BEGIN, NULL);
+//                if(indev_reset_check(proc)) return;
+//            }
 
         }
     }
@@ -1466,12 +1446,16 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
  */
 static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
 {
+
+    return obj;
+
     if(obj == NULL) return NULL;
     lv_obj_t * drag_obj = obj;
     while(lv_obj_get_drag_parent(drag_obj) != false && drag_obj != NULL) {
         drag_obj = lv_obj_get_parent(drag_obj);
     }
 
+    if(lv_obj_get_drag(drag_obj) == false) return NULL;
     return drag_obj;
 }
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 8f454d2c5..c39ddc647 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -96,6 +96,8 @@ static void trans_anim_start_cb(lv_anim_t * a);
 static void trans_anim_ready_cb(lv_anim_t * a);
 static void opa_scale_anim(lv_obj_t * obj, lv_anim_value_t v);
 static void fade_in_anim_ready(lv_anim_t * a);
+static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v);
+static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v);
 #endif
 static void lv_event_mark_deleted(lv_obj_t * obj);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
@@ -1074,6 +1076,7 @@ void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->scroll.y += y;
 
     refresh_children_position(obj, x, y);
+    lv_obj_invalidate(obj);
 }
 /**
  * Moves all children with horizontally or vertically.
@@ -1084,10 +1087,37 @@ void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
  */
 void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-    obj->scroll.x += x;
-    obj->scroll.y += y;
 
-    refresh_children_position(obj, x, y);
+    if(x == 0 && y == 0) return;
+
+    if(anim_en == LV_ANIM_ON) {
+        lv_disp_t * d = lv_obj_get_disp(obj);
+        lv_anim_t a;
+        lv_anim_init(&a);
+        lv_anim_set_var(&a, obj);
+
+        if(x) {
+            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_hor_res(d), 0, y));
+            lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
+            lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
+            lv_anim_start(&a);
+        }
+
+
+        if(y) {
+            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_ver_res(d), 0, y));
+            lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
+            lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
+            lv_anim_start(&a);
+        }
+
+    } else {
+        lv_obj_scroll_by_raw(obj, x, y);
+    }
+
+
+
+
 }
 
 /**
@@ -1118,7 +1148,7 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
  */
 void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-//    refresh_children_position(obj, x, y);
+    lv_obj_scroll_by(obj, 0, y - obj->scroll.y, anim_en);
 }
 
 /**
@@ -2125,6 +2155,37 @@ void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * cords_p)
     lv_area_copy(cords_p, &obj->coords);
 }
 
+/**
+ * Get a bounding which includes all the the children.
+ * `margin` of the children also taken into account and makes the box larger (if positive)
+ * @param obj pointer to an object
+ * @param coords pointer to an area to store the coordinates
+ * @return LV_RES_INV: `obj` has no children and `coords` can't be set; `LV_RES_OK`: success
+ */
+lv_res_t lv_obj_get_children_box(const lv_obj_t * obj, lv_area_t * coords)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    coords->x1 = LV_COORD_MAX;
+    coords->y1 = LV_COORD_MAX;
+    coords->x2 = LV_COORD_MIN;
+    coords->y2 = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child == NULL) return LV_RES_INV;
+
+    while(child) {
+        coords->x1 = LV_MATH_MIN(coords->x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
+        coords->y1 = LV_MATH_MIN(coords->y1, child->coords.y1 - lv_obj_get_style_margin_top(child, LV_OBJ_PART_MAIN));
+        coords->x2 = LV_MATH_MAX(coords->x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
+        coords->y2 = LV_MATH_MAX(coords->y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
+
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return LV_RES_OK;
+}
+
 /**
  * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
  * (Without the size of the border or other extra graphical elements)
@@ -2761,6 +2822,18 @@ lv_drag_dir_t lv_obj_get_drag_dir(const lv_obj_t * obj)
     return obj->drag_dir;
 }
 
+/**
+ * Get the directions an object can be scrolled
+ * @param obj pointer to an object
+ * @return bitwise OR of allowed directions an object can be dragged in
+ */
+lv_drag_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    return obj->scroll_dir;
+}
+
 /**
  * Get the drag throw enable attribute of an object
  * @param obj pointer to an object
@@ -3738,6 +3811,17 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         /*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_PRESS_LOST || sign == LV_SIGNAL_RELEASED) {
+
+        lv_area_t child_box;
+        lv_obj_get_children_box(obj, &child_box);
+        if(obj->scroll.y > 0) {
+            lv_obj_scroll_to_y(obj, 0, LV_ANIM_ON);
+        }
+        else if(child_box.y2 < obj->coords.y2) {
+            lv_obj_scroll_by(obj, 0, -(child_box.y2 - obj->coords.y2), LV_ANIM_ON);
+        }
+    }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         lv_coord_t d = lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
@@ -4278,6 +4362,15 @@ static void fade_in_anim_ready(lv_anim_t * a)
     lv_style_remove_prop(lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
 }
 
+
+static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
+{
+}
+
+static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
+{
+    lv_obj_scroll_by_raw(obj, 0, v - obj->scroll.y);
+}
 #endif
 
 static void lv_event_mark_deleted(lv_obj_t * obj)
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 112959fe1..b26543ca1 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -228,7 +228,8 @@ typedef struct _lv_obj_t {
     uint8_t gesture_parent  : 1; /**< 1: Parent will be gesture instead*/
     uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
 
-    lv_drag_dir_t drag_dir  : 3; /**<  Which directions the object can be dragged in */
+    lv_drag_dir_t drag_dir    : 3; /**< In which directions the object can be dragged */
+    lv_drag_dir_t scroll_dir  : 3; /**< In which directions the object can be scrolled */
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
 
 #if LV_USE_GROUP != 0
@@ -1223,6 +1224,13 @@ bool lv_obj_get_drag(const lv_obj_t * obj);
  */
 lv_drag_dir_t lv_obj_get_drag_dir(const lv_obj_t * obj);
 
+/**
+ * Get the directions an object can be scrolled
+ * @param obj pointer to an object
+ * @return bitwise OR of allowed directions an object can be dragged in
+ */
+lv_drag_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj);
+
 /**
  * Get the drag throw enable attribute of an object
  * @param obj pointer to an object

From bb68dde55d4385146075d2d5610f514bad5496b0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 7 Jul 2020 09:02:41 +0200
Subject: [PATCH 03/84] scroll: start scrollbar

---
 src/lv_core/lv_obj.c  | 58 +++++++++++++++++++++++++++++++++++++++++--
 src/lv_core/lv_obj.h  |  1 +
 src/lv_core/lv_refr.c |  2 +-
 3 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index c39ddc647..98c09b9bf 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -103,6 +103,7 @@ static void lv_event_mark_deleted(lv_obj_t * obj);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
+static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv);
 
 /**********************
  *  STATIC VARIABLES
@@ -1076,6 +1077,7 @@ void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->scroll.y += y;
 
     refresh_children_position(obj, x, y);
+    lv_signal_send(obj, LV_SIGNAL_SCROLLED, NULL);
     lv_obj_invalidate(obj);
 }
 /**
@@ -1103,11 +1105,14 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             lv_anim_start(&a);
         }
 
-
         if(y) {
-            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_ver_res(d), 0, y));
+            lv_anim_path_t path;
+            lv_anim_path_init(&path);
+            lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
+            lv_anim_set_time(&a, lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y));
             lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
             lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
+            lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
         }
 
@@ -3740,6 +3745,14 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             /*Add the mask and use `obj+8` as custom id. Don't use `obj` directly because it might be used by the user*/
             lv_draw_mask_add(mp, obj + 8);
         }
+
+            lv_area_t sb;
+            if(get_scrollbar_area(obj, &sb)) {
+                lv_draw_rect_dsc_t sb_rect_dsc;
+                lv_draw_rect_dsc_init(&sb_rect_dsc);
+                sb_rect_dsc.bg_color = LV_COLOR_RED;
+                lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
+            }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
@@ -3810,6 +3823,9 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     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_SCROLLED) {
+
     }
     else if(sign == LV_SIGNAL_PRESS_LOST || sign == LV_SIGNAL_RELEASED) {
 
@@ -4397,3 +4413,41 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 
     return false;
 }
+
+static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
+{
+    lv_coord_t obj_h = lv_obj_get_height(obj);
+
+    lv_area_t child_box;
+    lv_res_t res = lv_obj_get_children_box(obj, &child_box);
+    if(res != LV_RES_OK) return res;
+
+    lv_coord_t content_h = (child_box.y2 - obj->scroll.y) - obj->coords.y1 ;
+    if(content_h < obj_h) {
+        return LV_RES_INV;
+    }
+    lv_coord_t sb_h = (obj_h * obj_h) / content_h;
+    if(sb_h != 150) {
+        volatile int x = 0;
+    }
+    lv_coord_t rem = obj_h - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+    lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
+    if(scroll_h <= 0) {
+        sbv->y1 = obj->coords.y1;
+        sbv->y2 = obj->coords.y2;
+        sbv->x2 = obj->coords.x2;
+        sbv->x1 = sbv->x2 - 10;
+        return LV_RES_OK;
+    }
+    lv_coord_t sb_y = (rem * (child_box.y2 - obj->coords.y2)) / scroll_h;
+    printf("overflow: sb_h: %d, y: %d\n", sb_h, sb_y);
+
+    sbv->y1 = obj->coords.y1 + sb_y;
+    sbv->y2 = sbv->y1 + sb_h;
+    sbv->x2 = obj->coords.x2;
+    sbv->x1 = sbv->x2 - 10;
+
+    return LV_RES_OK;
+}
+
+
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index b26543ca1..88150db05 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -122,6 +122,7 @@ enum {
     /*General signals*/
     LV_SIGNAL_CLEANUP, /**< Object is being deleted */
     LV_SIGNAL_CHILD_CHG, /**< Child was removed/added */
+    LV_SIGNAL_SCROLLED, /**< Object coordinates/size have changed */
     LV_SIGNAL_COORD_CHG, /**< Object coordinates/size have changed */
     LV_SIGNAL_PARENT_SIZE_CHG, /**< Parent's size has changed */
     LV_SIGNAL_STYLE_CHG,    /**< Object's style has changed */
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index 9644a0459..834b59050 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -31,7 +31,7 @@
  *      DEFINES
  *********************/
 /* Draw translucent random colored areas on the invalidated (redrawn) areas*/
-#define MASK_AREA_DEBUG 0
+#define MASK_AREA_DEBUG 1
 
 /**********************
  *      TYPEDEFS

From 9cfd399fb305b7066cadeee3c0ebc50161ab9047 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 8 Jul 2020 12:29:47 +0200
Subject: [PATCH 04/84] scroll: add scroll throw

---
 src/lv_core/lv_indev.c | 114 +++++++++++++++++++++++++----------------
 src/lv_core/lv_obj.c   |   7 ++-
 src/lv_core/lv_obj.h   |   4 +-
 src/lv_core/lv_refr.c  |   2 +-
 4 files changed, 77 insertions(+), 50 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 88d6e58a4..37124a3bc 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1259,7 +1259,6 @@ static void indev_drag(lv_indev_proc_t * proc)
     if(target_obj == NULL) return;
 
     lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
-
     bool just_started = false;
 
     /*Get the coordinates of the object and modify them*/
@@ -1379,67 +1378,94 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
 {
     if(proc->types.pointer.drag_in_prog == 0) return;
 
-    lv_obj_t * drag_obj = get_dragged_obj(proc->types.pointer.last_obj);
 
-    if(drag_obj == NULL) return;
+    bool scrollable = true;
+
+    /*Get which object to drad/scroll*/
+    lv_obj_t * target_obj = get_dragged_obj(proc->types.pointer.last_obj);
+    if(target_obj == NULL) return;
 
     /*Return if the drag throw is not enabled*/
-    if(lv_obj_get_drag_throw(drag_obj) == false) {
-        proc->types.pointer.drag_in_prog = 0;
-        drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_END, indev_act);
-        if(indev_reset_check(proc)) return;
-
-        lv_event_send(drag_obj, LV_EVENT_DRAG_END, NULL);
-        return;
-    }
-
-    lv_drag_dir_t allowed_dirs = lv_obj_get_drag_dir(drag_obj);
+//    if(lv_obj_get_drag_throw(target_obj) == false) {
+//        proc->types.pointer.drag_in_prog = 0;
+//        target_obj->signal_cb(target_obj, scrollable ? LV_SIGNAL_SCROLL_END : LV_SIGNAL_DRAG_END, indev_act);
+//        if(indev_reset_check(proc)) return;
+//
+//        lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
+//        return;
+//    }
 
     /*Reduce the vectors*/
     proc->types.pointer.drag_throw_vect.x =
-        proc->types.pointer.drag_throw_vect.x * (100 - indev_act->driver.drag_throw) / 100;
+        proc->types.pointer.drag_throw_vect.x * (100 - indev_act->driver.drag_throw) / 30;
     proc->types.pointer.drag_throw_vect.y =
-        proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 100;
+        proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 30;
 
-    if(proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0) {
+    switch(proc->types.pointer.drag_dir) {
+    case LV_DRAG_DIR_HOR:
+        proc->types.pointer.drag_throw_vect.y = 0;
+        break;
+    case LV_DRAG_DIR_VER:
+        proc->types.pointer.drag_throw_vect.x = 0;
+        break;
+    }
+
+    lv_area_t child_box;
+    lv_obj_get_children_box(target_obj, &child_box);
+
+
+    if((target_obj->scroll.y < 0 && child_box.y2 > target_obj->coords.y2) &&
+       (proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0)) {
         /*Get the coordinates and modify them*/
-        lv_area_t coords_ori;
-        lv_obj_get_coords(drag_obj, &coords_ori);
-        lv_coord_t act_x = lv_obj_get_x(drag_obj) + proc->types.pointer.drag_throw_vect.x;
-        lv_coord_t act_y = lv_obj_get_y(drag_obj) + proc->types.pointer.drag_throw_vect.y;
+        if(scrollable) {
+            if(target_obj->scroll.y + proc->types.pointer.drag_throw_vect.y > 0) {
+                proc->types.pointer.drag_throw_vect.y = 0;
+                lv_obj_scroll_to_y(target_obj, 0, LV_ANIM_OFF);
+            }
+
+            if(child_box.y2 + proc->types.pointer.drag_throw_vect.y < target_obj->coords.y2) {
+                proc->types.pointer.drag_throw_vect.y = 0;
+                lv_obj_scroll_by(target_obj, 0, -(child_box.y2 - target_obj->coords.y2), LV_ANIM_OFF);
+            }
+
+
+                lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y);
+        } else {
+            lv_area_t coords_ori;
+            lv_obj_get_coords(target_obj, &coords_ori);
+
+            lv_coord_t act_x = lv_obj_get_x(target_obj) + proc->types.pointer.drag_throw_vect.x;
+            lv_coord_t act_y = lv_obj_get_y(target_obj) + proc->types.pointer.drag_throw_vect.y;
+            lv_obj_set_pos(target_obj, act_x, act_y);
+
+            lv_area_t coords_new;
+            lv_obj_get_coords(target_obj, &coords_new);
+
+            /*If non of the coordinates are changed then do not continue throwing*/
+            if((coords_ori.x1 == coords_new.x1 || proc->types.pointer.drag_throw_vect.x == 0) &&
+                    (coords_ori.y1 == coords_new.y1 || proc->types.pointer.drag_throw_vect.y == 0)) {
+                proc->types.pointer.drag_in_prog      = 0;
+                proc->types.pointer.vect.x            = 0;
+                proc->types.pointer.vect.y            = 0;
+                proc->types.pointer.drag_throw_vect.x = 0;
+                proc->types.pointer.drag_throw_vect.y = 0;
+                target_obj->signal_cb(target_obj, LV_SIGNAL_DRAG_END, indev_act);
+                if(indev_reset_check(proc)) return;
+
+                lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
+                if(indev_reset_check(proc)) return;
+            }
 
-        if(allowed_dirs == LV_DRAG_DIR_BOTH) lv_obj_set_pos(drag_obj, act_x, act_y);
-        else if(allowed_dirs == LV_DRAG_DIR_HOR) lv_obj_set_x(drag_obj, act_x);
-        else if(allowed_dirs == LV_DRAG_DIR_VER) lv_obj_set_y(drag_obj, act_y);
-        else if(allowed_dirs == LV_DRAG_DIR_ONE) {
-            if(proc->types.pointer.drag_sum.x) lv_obj_set_x(drag_obj, act_x);
-            else lv_obj_set_y(drag_obj, act_y);
         }
-        lv_area_t coord_new;
-        lv_obj_get_coords(drag_obj, &coord_new);
 
-        /*If non of the coordinates are changed then do not continue throwing*/
-        if((coords_ori.x1 == coord_new.x1 || proc->types.pointer.drag_throw_vect.x == 0) &&
-           (coords_ori.y1 == coord_new.y1 || proc->types.pointer.drag_throw_vect.y == 0)) {
-            proc->types.pointer.drag_in_prog      = 0;
-            proc->types.pointer.vect.x            = 0;
-            proc->types.pointer.vect.y            = 0;
-            proc->types.pointer.drag_throw_vect.x = 0;
-            proc->types.pointer.drag_throw_vect.y = 0;
-            drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_END, indev_act);
-            if(indev_reset_check(proc)) return;
-
-            lv_event_send(drag_obj, LV_EVENT_DRAG_END, NULL);
-            if(indev_reset_check(proc)) return;
-        }
     }
     /*If the types.pointer.vectors become 0 -> types.pointer.drag_in_prog = 0 and send a drag end
        signal*/
     else {
         proc->types.pointer.drag_in_prog = 0;
-        drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_END, indev_act);
+        target_obj->signal_cb(target_obj, scrollable ? LV_SIGNAL_SCROLL_END : LV_SIGNAL_DRAG_END, indev_act);
         if(indev_reset_check(proc)) return;
-        lv_event_send(drag_obj, LV_EVENT_DRAG_END, NULL);
+        lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
         if(indev_reset_check(proc)) return;
     }
 }
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 3e137a904..49cfe7521 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1078,7 +1078,7 @@ void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->scroll.y += y;
 
     refresh_children_position(obj, x, y);
-    lv_signal_send(obj, LV_SIGNAL_SCROLLED, NULL);
+    lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
     lv_obj_invalidate(obj);
 }
 /**
@@ -3890,10 +3890,10 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         /*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_SCROLLED) {
+    else if(sign == LV_SIGNAL_SCROLL) {
 
     }
-    else if(sign == LV_SIGNAL_PRESS_LOST || sign == LV_SIGNAL_RELEASED) {
+    else if(sign == LV_SIGNAL_SCROLL_END) {
 
         lv_area_t child_box;
         lv_obj_get_children_box(obj, &child_box);
@@ -4511,7 +4511,6 @@ static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
         return LV_RES_OK;
     }
     lv_coord_t sb_y = (rem * (child_box.y2 - obj->coords.y2)) / scroll_h;
-    printf("overflow: sb_h: %d, y: %d\n", sb_h, sb_y);
 
     sbv->y1 = obj->coords.y1 + sb_y;
     sbv->y2 = sbv->y1 + sb_h;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 7a4c40c6d..7533b4c3a 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -122,7 +122,6 @@ enum {
     /*General signals*/
     LV_SIGNAL_CLEANUP, /**< Object is being deleted */
     LV_SIGNAL_CHILD_CHG, /**< Child was removed/added */
-    LV_SIGNAL_SCROLLED, /**< Object coordinates/size have changed */
     LV_SIGNAL_COORD_CHG, /**< Object coordinates/size have changed */
     LV_SIGNAL_PARENT_SIZE_CHG, /**< Parent's size has changed */
     LV_SIGNAL_STYLE_CHG,    /**< Object's style has changed */
@@ -140,6 +139,9 @@ enum {
     LV_SIGNAL_RELEASED,          /**< User pressed object for a short period of time, then released it. Not called if dragged. */
     LV_SIGNAL_LONG_PRESS,        /**< Object has been pressed for at least `LV_INDEV_LONG_PRESS_TIME`.  Not called if dragged.*/
     LV_SIGNAL_LONG_PRESS_REP,    /**< Called after `LV_INDEV_LONG_PRESS_TIME` in every `LV_INDEV_LONG_PRESS_REP_TIME` ms.  Not called if dragged.*/
+    LV_SIGNAL_SCROLL_BEGIN,      /**< The scrolling has just begun  */
+    LV_SIGNAL_SCROLL,            /**< The object has been scrolled */
+    LV_SIGNAL_SCROLL_END,        /**< The scrolling has ended */
     LV_SIGNAL_DRAG_BEGIN,
     LV_SIGNAL_DRAG_THROW_BEGIN,
     LV_SIGNAL_DRAG_END,
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index 834b59050..9644a0459 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -31,7 +31,7 @@
  *      DEFINES
  *********************/
 /* Draw translucent random colored areas on the invalidated (redrawn) areas*/
-#define MASK_AREA_DEBUG 1
+#define MASK_AREA_DEBUG 0
 
 /**********************
  *      TYPEDEFS

From 0cea8b2c0866ff4c1301b1343b1669951a0b3be9 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 8 Jul 2020 14:59:19 +0200
Subject: [PATCH 05/84] scroll: wip

---
 src/lv_core/lv_indev.c    | 161 +++++++++++++++++++++++++++-----------
 src/lv_core/lv_obj.c      |  37 +++++++++
 src/lv_core/lv_obj.h      |  60 ++++++++++++++
 src/lv_hal/lv_hal_indev.h |   1 +
 4 files changed, 214 insertions(+), 45 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 37124a3bc..775c484f3 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1095,6 +1095,7 @@ static void indev_proc_reset_query_handler(lv_indev_t * indev)
     if(indev->proc.reset_query) {
         indev->proc.types.pointer.act_obj           = NULL;
         indev->proc.types.pointer.last_obj          = NULL;
+        indev->proc.types.pointer.drag_obj          = NULL;
         indev->proc.types.pointer.drag_limit_out    = 0;
         indev->proc.types.pointer.drag_in_prog      = 0;
         indev->proc.long_pr_sent                    = 0;
@@ -1251,72 +1252,131 @@ static void indev_click_focus(lv_indev_proc_t * proc)
  */
 static void indev_drag(lv_indev_proc_t * proc)
 {
-
     bool scrollable = true;
 
     /*Get which object to drad/scroll*/
-    lv_obj_t * target_obj = get_dragged_obj(proc->types.pointer.act_obj);
-    if(target_obj == NULL) return;
-
     lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
     bool just_started = false;
 
-    /*Get the coordinates of the object and modify them*/
-    lv_coord_t act_x = lv_obj_get_x(target_obj);
-    lv_coord_t act_y = lv_obj_get_y(target_obj);
+    lv_coord_t act_x = 0;
+    lv_coord_t act_y = 0;
 
     /*Count the movement by drag*/
     if(proc->types.pointer.drag_limit_out == 0) {
         proc->types.pointer.drag_sum.x += proc->types.pointer.vect.x;
         proc->types.pointer.drag_sum.y += proc->types.pointer.vect.y;
 
-        /*Enough move?*/
-        bool hor_en = false;
-        bool ver_en = false;
-        if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
-            hor_en = true;
-        }
+        proc->types.pointer.drag_obj = proc->types.pointer.act_obj;
 
-        if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
-            ver_en = true;
-        }
+        /*Go until find the object or parent scrollable in this direction*/
+        while(proc->types.pointer.drag_obj) {
+            dirs = LV_DRAG_DIR_VER;
 
-        if(dirs == LV_DRAG_DIR_ONE) {
-            if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
+            /*Enough move?*/
+            bool hor_en = false;
+            bool ver_en = false;
+            if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
                 hor_en = true;
             }
-            else {
+
+            if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
                 ver_en = true;
             }
-        }
 
-        /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
-        if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
-           (ver_en && LV_MATH_ABS(proc->types.pointer.drag_sum.y) >= indev_act->driver.drag_limit)) {
-            proc->types.pointer.drag_limit_out = 1;
-            just_started = true;
             if(dirs == LV_DRAG_DIR_ONE) {
-                proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
-            } else {
-                proc->types.pointer.drag_dir = dirs;
+                if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
+                    hor_en = true;
+                }
+                else {
+                    ver_en = true;
+                }
             }
 
-            /*The was no move due to drag limit. Compensate it now.*/
-            if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
-            if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
+            bool up_en = ver_en;
+            bool down_en = ver_en;
 
-            act_x += proc->types.pointer.drag_sum.x;
-            act_y += proc->types.pointer.drag_sum.y;
+            if(lv_obj_get_scroll_top(proc->types.pointer.drag_obj) <= 0) up_en = false;
+            if(lv_obj_get_scroll_bottom(proc->types.pointer.drag_obj) <= 0) down_en = false;
+
+            /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
+            if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
+               (up_en && proc->types.pointer.drag_sum.y >= indev_act->driver.drag_limit) ||
+               (down_en && proc->types.pointer.drag_sum.y <= -indev_act->driver.drag_limit)) {
+                proc->types.pointer.drag_limit_out = 1;
+                just_started = true;
+                if(dirs == LV_DRAG_DIR_ONE) {
+                    proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
+                } else {
+                    proc->types.pointer.drag_dir = dirs;
+                }
+
+                /*The was no move due to drag limit. Compensate it now.*/
+                if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
+                if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
+
+                act_x = lv_obj_get_x(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.x;
+                act_y = lv_obj_get_y(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.y;
+                break;
+            }
+            proc->types.pointer.drag_obj = lv_obj_get_parent(proc->types.pointer.drag_obj);
         }
     }
 
+    /*If the drag/scroll can't be propagated to any parent show an elastic scroll in the original object*/
+    if(proc->types.pointer.drag_obj == NULL) {
+        proc->types.pointer.drag_obj = proc->types.pointer.act_obj;
+//
+//        dirs = LV_DRAG_DIR_VER;
+//
+//        /*Enough move?*/
+//        bool hor_en = false;
+//        bool ver_en = false;
+//        if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
+//            hor_en = true;
+//        }
+//
+//        if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
+//            ver_en = true;
+//        }
+//
+//        if(dirs == LV_DRAG_DIR_ONE) {
+//            if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
+//                hor_en = true;
+//            }
+//            else {
+//                ver_en = true;
+//            }
+//        }
+//
+//        /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
+//        if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
+//                (ver_en && LV_MATH_ABS(proc->types.pointer.drag_sum.y) >= indev_act->driver.drag_limit)) {
+//            proc->types.pointer.drag_limit_out = 1;
+//            just_started = true;
+//            if(dirs == LV_DRAG_DIR_ONE) {
+//                proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
+//            } else {
+//                proc->types.pointer.drag_dir = dirs;
+//            }
+//
+//            /*The was no move due to drag limit. Compensate it now.*/
+//            if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
+//            if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
+//
+//            act_x = lv_obj_get_x(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.x;
+//            act_y = lv_obj_get_y(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.y;
+//        }
+
+    }
+    lv_obj_t * obj = proc->types.pointer.drag_obj;
+
     /*If the drag limit is exceeded handle the dragging*/
     if(proc->types.pointer.drag_limit_out != 0) {
         /*Set new position or scroll if the vector is not zero*/
         if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
 
-            lv_coord_t prev_x     = target_obj->coords.x1;
-            lv_coord_t prev_y     = target_obj->coords.y1;
+            lv_coord_t prev_x     = obj->coords.x1;
+            lv_coord_t prev_y     = obj->coords.y1;
 
             /*Move the object. `drag_sum` is zerod out for *disabled direction*/
             if(proc->types.pointer.drag_sum.x) act_x += proc->types.pointer.vect.x;
@@ -1327,18 +1387,18 @@ static void indev_drag(lv_indev_proc_t * proc)
 
             if(scrollable) {
                 lv_area_t child_box;
-                lv_obj_get_children_box(target_obj, &child_box);
+                lv_obj_get_children_box(obj, &child_box);
                 lv_coord_t diff_y = proc->types.pointer.vect.y;
-                if(target_obj->scroll.y > 0 && diff_y > 0) {
+                if(obj->scroll.y > 0 && diff_y > 0) {
                     diff_y = diff_y / 2;
                 }
-                if(child_box.y2 < target_obj->coords.y2 && diff_y < 0) {
+                if(child_box.y2 < obj->coords.y2 && diff_y < 0) {
                     diff_y = diff_y / 2;
                 }
 
-                lv_obj_scroll_by(target_obj, 0, diff_y, LV_ANIM_OFF);
+                lv_obj_scroll_by(obj, 0, diff_y, LV_ANIM_OFF);
             } else {
-                lv_obj_set_pos(target_obj, act_x, act_y);
+                lv_obj_set_pos(obj, act_x, act_y);
             }
 
             proc->types.pointer.drag_in_prog = 1;
@@ -1397,9 +1457,9 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
 
     /*Reduce the vectors*/
     proc->types.pointer.drag_throw_vect.x =
-        proc->types.pointer.drag_throw_vect.x * (100 - indev_act->driver.drag_throw) / 30;
+        proc->types.pointer.drag_throw_vect.x * (100 - indev_act->driver.drag_throw) / 100;
     proc->types.pointer.drag_throw_vect.y =
-        proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 30;
+        proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 100;
 
     switch(proc->types.pointer.drag_dir) {
     case LV_DRAG_DIR_HOR:
@@ -1428,8 +1488,7 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
                 lv_obj_scroll_by(target_obj, 0, -(child_box.y2 - target_obj->coords.y2), LV_ANIM_OFF);
             }
 
-
-                lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y);
+            lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y, LV_ANIM_OFF);
         } else {
             lv_area_t coords_ori;
             lv_obj_get_coords(target_obj, &coords_ori);
@@ -1463,6 +1522,7 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
        signal*/
     else {
         proc->types.pointer.drag_in_prog = 0;
+        proc->types.pointer.drag_obj = NULL;
         target_obj->signal_cb(target_obj, scrollable ? LV_SIGNAL_SCROLL_END : LV_SIGNAL_DRAG_END, indev_act);
         if(indev_reset_check(proc)) return;
         lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
@@ -1478,9 +1538,20 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
  */
 static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
 {
-
     return obj;
 
+    if(indev_act->proc.types.pointer.drag_obj) {
+        return indev_act->proc.types.pointer.drag_obj;
+    } else {
+        lv_area_t child_box;
+        lv_obj_get_children_box(obj, &child_box);
+        if(child_box.y2 == obj->coords.y2) indev_act->proc.types.pointer.drag_obj = lv_obj_get_parent(obj);
+        else indev_act->proc.types.pointer.drag_obj = obj;
+    }
+
+    return indev_act->proc.types.pointer.drag_obj;
+
+
     if(obj == NULL) return NULL;
     lv_obj_t * drag_obj = obj;
     while(lv_obj_get_drag_parent(drag_obj) != false && drag_obj != NULL) {
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 49cfe7521..0bd559ba5 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1157,6 +1157,43 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
     lv_obj_scroll_by(obj, 0, y - obj->scroll.y, anim_en);
 }
 
+
+/**
+ * Return the height of the area above the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
+{
+    return -obj->scroll.y;
+}
+
+/**
+ * Return the height of the area below the parent.
+ * That is the number of pixels the object can be scrolled up.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t y2 = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child == NULL) return 0;
+
+    while(child) {
+        y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return y2 - obj->coords.y2;
+}
+
 /**
  * Set the size of an extended clickable area
  * If TINY mode is used, only the largest of the horizontal and vertical padding
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 7533b4c3a..c914616ea 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -534,6 +534,66 @@ void lv_obj_realign(lv_obj_t * obj);
  */
 void lv_obj_set_auto_realign(lv_obj_t * obj, bool en);
 
+/**
+ * Moves all children with horizontally or vertically.
+ * It doesn't take into account any limits so any values are possible
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Moves all children with horizontally or vertically.
+ * Limits the scroll to the bounding box of the children.
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ */
+void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given y coordinate to the top side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
+
+
+/**
+ * Return the height of the area above the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj);
+
+/**
+ * Return the height of the area below the parent.
+ * That is the number of pixels the object can be scrolled up.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj);
+
+
 /**
  * Set the size of an extended clickable area
  * @param obj pointer to an object
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index 1d4f77e7a..6f77ccef2 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -139,6 +139,7 @@ typedef struct _lv_indev_proc_t {
             struct _lv_obj_t * act_obj;      /*The object being pressed*/
             struct _lv_obj_t * last_obj;     /*The last object which was pressed (used by drag_throw and
                                                 other post-release event)*/
+            struct _lv_obj_t * drag_obj;      /*The object being pressed*/
             struct _lv_obj_t * last_pressed; /*The lastly pressed object*/
 
             lv_gesture_dir_t gesture_dir;

From ce0fb2da4d7d078a2965f39bec700b711350a20a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 8 Jul 2020 20:07:10 +0200
Subject: [PATCH 06/84] scroll: add scroll chain

---
 src/lv_core/lv_indev.c    | 153 +++++++++++++++-----------------------
 src/lv_core/lv_obj.c      |   4 +
 src/lv_hal/lv_hal_indev.h |   1 +
 3 files changed, 64 insertions(+), 94 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 775c484f3..3ec8ae962 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -940,18 +940,8 @@ static void indev_proc_press(lv_indev_proc_t * proc)
     proc->types.pointer.vect.x = proc->types.pointer.act_point.x - proc->types.pointer.last_point.x;
     proc->types.pointer.vect.y = proc->types.pointer.act_point.y - proc->types.pointer.last_point.y;
 
-    proc->types.pointer.drag_throw_vect.x = (proc->types.pointer.drag_throw_vect.x * 5) >> 3;
-    proc->types.pointer.drag_throw_vect.y = (proc->types.pointer.drag_throw_vect.y * 5) >> 3;
-
-    if(proc->types.pointer.drag_throw_vect.x < 0)
-        proc->types.pointer.drag_throw_vect.x++;
-    else if(proc->types.pointer.drag_throw_vect.x > 0)
-        proc->types.pointer.drag_throw_vect.x--;
-
-    if(proc->types.pointer.drag_throw_vect.y < 0)
-        proc->types.pointer.drag_throw_vect.y++;
-    else if(proc->types.pointer.drag_throw_vect.y > 0)
-        proc->types.pointer.drag_throw_vect.y--;
+    proc->types.pointer.drag_throw_vect.x = (proc->types.pointer.drag_throw_vect.x * 4) >> 3;
+    proc->types.pointer.drag_throw_vect.y = (proc->types.pointer.drag_throw_vect.y * 4) >> 3;
 
     proc->types.pointer.drag_throw_vect.x += (proc->types.pointer.vect.x * 4) >> 3;
     proc->types.pointer.drag_throw_vect.y += (proc->types.pointer.vect.y * 4) >> 3;
@@ -1254,12 +1244,10 @@ static void indev_drag(lv_indev_proc_t * proc)
 {
     bool scrollable = true;
 
-    /*Get which object to drad/scroll*/
-    lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
-    bool just_started = false;
-
     lv_coord_t act_x = 0;
     lv_coord_t act_y = 0;
+    lv_obj_t * scroll_candidate_obj = NULL;
+    lv_drag_dir_t dirs_candidate = LV_DRAG_DIR_NONE;
 
     /*Count the movement by drag*/
     if(proc->types.pointer.drag_limit_out == 0) {
@@ -1270,19 +1258,14 @@ static void indev_drag(lv_indev_proc_t * proc)
 
         /*Go until find the object or parent scrollable in this direction*/
         while(proc->types.pointer.drag_obj) {
-            dirs = LV_DRAG_DIR_VER;
+            /*Get which object to drad/scroll*/
+            lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
 
             /*Enough move?*/
             bool hor_en = false;
             bool ver_en = false;
-            if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
-                hor_en = true;
-            }
-
-            if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
-                ver_en = true;
-            }
-
+            if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) hor_en = true;
+            if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) ver_en = true;
             if(dirs == LV_DRAG_DIR_ONE) {
                 if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
                     hor_en = true;
@@ -1294,16 +1277,30 @@ static void indev_drag(lv_indev_proc_t * proc)
 
             bool up_en = ver_en;
             bool down_en = ver_en;
+            bool left_en = hor_en;
+            bool right_en = hor_en;
+
+            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.drag_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.drag_obj);
+
+            if((up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
+               (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit))
+            {
+                scroll_candidate_obj = proc->types.pointer.drag_obj;
+                dirs_candidate = LV_DRAG_DIR_VER;
+            }
+
+            if(st <= 0) up_en = false;
+            if(sb <= 0) down_en = false;
 
-            if(lv_obj_get_scroll_top(proc->types.pointer.drag_obj) <= 0) up_en = false;
-            if(lv_obj_get_scroll_bottom(proc->types.pointer.drag_obj) <= 0) down_en = false;
 
             /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
-            if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
-               (up_en && proc->types.pointer.drag_sum.y >= indev_act->driver.drag_limit) ||
-               (down_en && proc->types.pointer.drag_sum.y <= -indev_act->driver.drag_limit)) {
+            if((left_en  && proc->types.pointer.drag_sum.x >=   indev_act->driver.drag_limit) ||
+               (right_en && proc->types.pointer.drag_sum.x <= - indev_act->driver.drag_limit) ||
+               (up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
+               (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit))
+            {
                 proc->types.pointer.drag_limit_out = 1;
-                just_started = true;
                 if(dirs == LV_DRAG_DIR_ONE) {
                     proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
                 } else {
@@ -1324,50 +1321,15 @@ static void indev_drag(lv_indev_proc_t * proc)
 
     /*If the drag/scroll can't be propagated to any parent show an elastic scroll in the original object*/
     if(proc->types.pointer.drag_obj == NULL) {
-        proc->types.pointer.drag_obj = proc->types.pointer.act_obj;
-//
-//        dirs = LV_DRAG_DIR_VER;
-//
-//        /*Enough move?*/
-//        bool hor_en = false;
-//        bool ver_en = false;
-//        if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) {
-//            hor_en = true;
-//        }
-//
-//        if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) {
-//            ver_en = true;
-//        }
-//
-//        if(dirs == LV_DRAG_DIR_ONE) {
-//            if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
-//                hor_en = true;
-//            }
-//            else {
-//                ver_en = true;
-//            }
-//        }
-//
-//        /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
-//        if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
-//                (ver_en && LV_MATH_ABS(proc->types.pointer.drag_sum.y) >= indev_act->driver.drag_limit)) {
-//            proc->types.pointer.drag_limit_out = 1;
-//            just_started = true;
-//            if(dirs == LV_DRAG_DIR_ONE) {
-//                proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
-//            } else {
-//                proc->types.pointer.drag_dir = dirs;
-//            }
-//
-//            /*The was no move due to drag limit. Compensate it now.*/
-//            if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
-//            if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
-//
-//            act_x = lv_obj_get_x(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.x;
-//            act_y = lv_obj_get_y(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.y;
-//        }
-
+        if(scroll_candidate_obj) {
+            proc->types.pointer.drag_limit_out = 1;
+            proc->types.pointer.drag_dir = dirs_candidate;
+            proc->types.pointer.drag_obj = scroll_candidate_obj;
+        } else {
+            return;
+        }
     }
+
     lv_obj_t * obj = proc->types.pointer.drag_obj;
 
     /*If the drag limit is exceeded handle the dragging*/
@@ -1442,7 +1404,7 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
     bool scrollable = true;
 
     /*Get which object to drad/scroll*/
-    lv_obj_t * target_obj = get_dragged_obj(proc->types.pointer.last_obj);
+    lv_obj_t * target_obj = proc->types.pointer.drag_obj;
     if(target_obj == NULL) return;
 
     /*Return if the drag throw is not enabled*/
@@ -1462,31 +1424,34 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
         proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 100;
 
     switch(proc->types.pointer.drag_dir) {
-    case LV_DRAG_DIR_HOR:
-        proc->types.pointer.drag_throw_vect.y = 0;
-        break;
-    case LV_DRAG_DIR_VER:
-        proc->types.pointer.drag_throw_vect.x = 0;
-        break;
+        case LV_DRAG_DIR_HOR:
+            proc->types.pointer.drag_throw_vect.y = 0;
+            break;
+        case LV_DRAG_DIR_VER:
+        {
+            proc->types.pointer.drag_throw_vect.x = 0;
+            lv_coord_t st = lv_obj_get_scroll_top(target_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(target_obj);
+            /*If scrolled inside reduce faster*/
+            if(st < 0 || sb < 0) proc->types.pointer.drag_throw_vect.y = proc->types.pointer.drag_throw_vect.y >> 1;
+            break;
+        }
     }
 
-    lv_area_t child_box;
-    lv_obj_get_children_box(target_obj, &child_box);
 
 
-    if((target_obj->scroll.y < 0 && child_box.y2 > target_obj->coords.y2) &&
-       (proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0)) {
+    if((proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0)) {
         /*Get the coordinates and modify them*/
         if(scrollable) {
-            if(target_obj->scroll.y + proc->types.pointer.drag_throw_vect.y > 0) {
-                proc->types.pointer.drag_throw_vect.y = 0;
-                lv_obj_scroll_to_y(target_obj, 0, LV_ANIM_OFF);
-            }
-
-            if(child_box.y2 + proc->types.pointer.drag_throw_vect.y < target_obj->coords.y2) {
-                proc->types.pointer.drag_throw_vect.y = 0;
-                lv_obj_scroll_by(target_obj, 0, -(child_box.y2 - target_obj->coords.y2), LV_ANIM_OFF);
-            }
+//            if(target_obj->scroll.y + proc->types.pointer.drag_throw_vect.y > 0) {
+//                proc->types.pointer.drag_throw_vect.y = 0;
+//                lv_obj_scroll_to_y(target_obj, 0, LV_ANIM_OFF);
+//            }
+//
+//            if(child_box.y2 + proc->types.pointer.drag_throw_vect.y < target_obj->coords.y2) {
+//                proc->types.pointer.drag_throw_vect.y = 0;
+//                lv_obj_scroll_by(target_obj, 0, -(child_box.y2 - target_obj->coords.y2), LV_ANIM_OFF);
+//            }
 
             lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y, LV_ANIM_OFF);
         } else {
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 0bd559ba5..8ef882f83 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -3849,6 +3849,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             lv_draw_mask_add(mp, obj + 8);
         }
 
+        if(lv_obj_get_screen(obj) == lv_scr_act()) {
             lv_area_t sb;
             if(get_scrollbar_area(obj, &sb)) {
                 lv_draw_rect_dsc_t sb_rect_dsc;
@@ -3856,6 +3857,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
                 sb_rect_dsc.bg_color = LV_COLOR_RED;
                 lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
             }
+        }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
@@ -4548,6 +4550,8 @@ static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
         return LV_RES_OK;
     }
     lv_coord_t sb_y = (rem * (child_box.y2 - obj->coords.y2)) / scroll_h;
+    sb_y = rem - sb_y;
+
 
     sbv->y1 = obj->coords.y1 + sb_y;
     sbv->y2 = sbv->y1 + sb_h;
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index 6f77ccef2..a4af05936 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -52,6 +52,7 @@ typedef uint8_t lv_indev_state_t;
 
 
 enum {
+    LV_DRAG_DIR_NONE = 0x0, /**< Object can't be dragged to any directions. */
     LV_DRAG_DIR_HOR = 0x1, /**< Object can be dragged horizontally. */
     LV_DRAG_DIR_VER = 0x2, /**< Object can be dragged vertically. */
     LV_DRAG_DIR_BOTH = 0x3, /**< Object can be dragged in all directions. */

From f3a1028064c3c6e3600345e0c3bac89c4dc962ff Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 14 Jul 2020 15:23:20 +0200
Subject: [PATCH 07/84] scroll: handle horizontayl scrolling

---
 src/lv_core/lv_indev.c |  49 +++++++++------
 src/lv_core/lv_obj.c   | 133 ++++++++++++++++++++++++++++++++++-------
 src/lv_core/lv_obj.h   |  18 ++++++
 3 files changed, 159 insertions(+), 41 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 3ec8ae962..a415dc1ec 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1259,7 +1259,7 @@ static void indev_drag(lv_indev_proc_t * proc)
         /*Go until find the object or parent scrollable in this direction*/
         while(proc->types.pointer.drag_obj) {
             /*Get which object to drad/scroll*/
-            lv_drag_dir_t dirs = LV_DRAG_DIR_VER; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
+            lv_drag_dir_t dirs = LV_DRAG_DIR_ONE; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
 
             /*Enough move?*/
             bool hor_en = false;
@@ -1282,16 +1282,32 @@ static void indev_drag(lv_indev_proc_t * proc)
 
             lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.drag_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.drag_obj);
+            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.drag_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.drag_obj);
 
-            if((up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
-               (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit))
+            bool ver_scrollable = st > 0 || sb > 0 ? true : false;
+            bool hor_scrollable = sl > 0 || sr > 0 ? true : false;
+
+            if(ver_scrollable &&
+               ((up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
+                (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit)))
             {
                 scroll_candidate_obj = proc->types.pointer.drag_obj;
                 dirs_candidate = LV_DRAG_DIR_VER;
             }
 
+            if(hor_scrollable &&
+              ((left_en    && proc->types.pointer.drag_sum.x >=   indev_act->driver.drag_limit) ||
+               (right_en  && proc->types.pointer.drag_sum.x <= - indev_act->driver.drag_limit)))
+            {
+                scroll_candidate_obj = proc->types.pointer.drag_obj;
+                dirs_candidate = LV_DRAG_DIR_HOR;
+            }
+
             if(st <= 0) up_en = false;
             if(sb <= 0) down_en = false;
+            if(sl <= 0) left_en = false;
+            if(sr <= 0) right_en = false;
 
 
             /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
@@ -1350,15 +1366,16 @@ static void indev_drag(lv_indev_proc_t * proc)
             if(scrollable) {
                 lv_area_t child_box;
                 lv_obj_get_children_box(obj, &child_box);
-                lv_coord_t diff_y = proc->types.pointer.vect.y;
-                if(obj->scroll.y > 0 && diff_y > 0) {
-                    diff_y = diff_y / 2;
+                lv_coord_t diff_y = proc->types.pointer.drag_dir == LV_DRAG_DIR_VER ? proc->types.pointer.vect.y : 0;
+                lv_coord_t diff_x = proc->types.pointer.drag_dir == LV_DRAG_DIR_HOR ? proc->types.pointer.vect.x : 0;
+                if(obj->scroll.x > 0 && diff_x > 0) {
+                    diff_x = diff_x / 2;
                 }
                 if(child_box.y2 < obj->coords.y2 && diff_y < 0) {
                     diff_y = diff_y / 2;
                 }
 
-                lv_obj_scroll_by(obj, 0, diff_y, LV_ANIM_OFF);
+                lv_obj_scroll_by(obj, diff_x, diff_y, LV_ANIM_OFF);
             } else {
                 lv_obj_set_pos(obj, act_x, act_y);
             }
@@ -1425,8 +1442,14 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
 
     switch(proc->types.pointer.drag_dir) {
         case LV_DRAG_DIR_HOR:
+        {
             proc->types.pointer.drag_throw_vect.y = 0;
+            lv_coord_t sl = lv_obj_get_scroll_left(target_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(target_obj);
+            /*If scrolled inside reduce faster*/
+            if(sl < 0 || sr < 0) proc->types.pointer.drag_throw_vect.x = proc->types.pointer.drag_throw_vect.x >> 1;
             break;
+        }
         case LV_DRAG_DIR_VER:
         {
             proc->types.pointer.drag_throw_vect.x = 0;
@@ -1438,21 +1461,9 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
         }
     }
 
-
-
     if((proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0)) {
         /*Get the coordinates and modify them*/
         if(scrollable) {
-//            if(target_obj->scroll.y + proc->types.pointer.drag_throw_vect.y > 0) {
-//                proc->types.pointer.drag_throw_vect.y = 0;
-//                lv_obj_scroll_to_y(target_obj, 0, LV_ANIM_OFF);
-//            }
-//
-//            if(child_box.y2 + proc->types.pointer.drag_throw_vect.y < target_obj->coords.y2) {
-//                proc->types.pointer.drag_throw_vect.y = 0;
-//                lv_obj_scroll_by(target_obj, 0, -(child_box.y2 - target_obj->coords.y2), LV_ANIM_OFF);
-//            }
-
             lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y, LV_ANIM_OFF);
         } else {
             lv_area_t coords_ori;
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 8ef882f83..876115330 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -104,7 +104,8 @@ static void refresh_event_task_cb(lv_task_t * t);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
-static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv);
+static lv_res_t get_ver_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv);
+static lv_res_t get_hor_scrollbar_area(lv_obj_t * obj, lv_area_t * sbh);
 
 /**********************
  *  STATIC VARIABLES
@@ -1099,31 +1100,28 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
         lv_anim_init(&a);
         lv_anim_set_var(&a, obj);
 
+        lv_anim_path_t path;
+        lv_anim_path_init(&path);
+        lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
+
         if(x) {
-            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_hor_res(d), 0, y));
+            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_hor_res(d), 0, x));
             lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
             lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
+            lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
         }
 
         if(y) {
-            lv_anim_path_t path;
-            lv_anim_path_init(&path);
-            lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
             lv_anim_set_time(&a, lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y));
             lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
             lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
             lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
         }
-
     } else {
         lv_obj_scroll_by_raw(obj, x, y);
     }
-
-
-
-
 }
 
 /**
@@ -1144,7 +1142,7 @@ void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  */
 void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 {
-//    refresh_children_position(obj, x, y);
+    lv_obj_scroll_by(obj, x - obj->scroll.x, 0, anim_en);
 }
 
 /**
@@ -1194,6 +1192,42 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
     return y2 - obj->coords.y2;
 }
 
+/**
+ * Return the weight of the area on the left the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
+{
+    return -obj->scroll.x;
+}
+
+/**
+ * Return the width of the area below the object.
+ * That is the number of pixels the object can be scrolled left.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t x2 = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child == NULL) return 0;
+
+    while(child) {
+        x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return x2 - obj->coords.x2;
+}
+
 /**
  * Set the size of an extended clickable area
  * If TINY mode is used, only the largest of the horizontal and vertical padding
@@ -3851,12 +3885,19 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
 
         if(lv_obj_get_screen(obj) == lv_scr_act()) {
             lv_area_t sb;
-            if(get_scrollbar_area(obj, &sb)) {
+            if(get_ver_scrollbar_area(obj, &sb)) {
                 lv_draw_rect_dsc_t sb_rect_dsc;
                 lv_draw_rect_dsc_init(&sb_rect_dsc);
                 sb_rect_dsc.bg_color = LV_COLOR_RED;
                 lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
             }
+
+            if(get_hor_scrollbar_area(obj, &sb)) {
+                lv_draw_rect_dsc_t sb_rect_dsc;
+                lv_draw_rect_dsc_init(&sb_rect_dsc);
+                sb_rect_dsc.bg_color = LV_COLOR_BLUE;
+                lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
+            }
         }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
@@ -3934,13 +3975,30 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     }
     else if(sign == LV_SIGNAL_SCROLL_END) {
 
-        lv_area_t child_box;
-        lv_obj_get_children_box(obj, &child_box);
-        if(obj->scroll.y > 0) {
-            lv_obj_scroll_to_y(obj, 0, LV_ANIM_ON);
+//        lv_area_t child_box;
+//        lv_obj_get_children_box(obj, &child_box);
+
+        lv_coord_t st = lv_obj_get_scroll_top(obj);
+        lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
+        lv_coord_t sl = lv_obj_get_scroll_left(obj);
+        lv_coord_t sr = lv_obj_get_scroll_right(obj);
+
+        /*Revert if scrolled in*/
+        if(st > 0 || sb > 0) { /*Is vertically scrollable*/
+            if(st < 0) {
+                lv_obj_scroll_by(obj, 0, st, LV_ANIM_ON);
+            }
+            else if(sb < 0) {
+                lv_obj_scroll_by(obj, 0, -sb, LV_ANIM_ON);
+            }
         }
-        else if(child_box.y2 < obj->coords.y2) {
-            lv_obj_scroll_by(obj, 0, -(child_box.y2 - obj->coords.y2), LV_ANIM_ON);
+        if(sl > 0 || sr > 0) { /*Is horizontally scrollable*/
+            if(sl < 0) {
+                lv_obj_scroll_by(obj, sl, 0, LV_ANIM_ON);
+            }
+            else if(sr < 0) {
+                lv_obj_scroll_by(obj, -sr, 0, LV_ANIM_ON);
+            }
         }
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
@@ -4486,6 +4544,7 @@ static void fade_in_anim_ready(lv_anim_t * a)
 
 static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
+    lv_obj_scroll_by_raw(obj, v - obj->scroll.x, 0);
 }
 
 static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
@@ -4524,7 +4583,7 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
     return false;
 }
 
-static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
+static lv_res_t get_ver_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
 {
     lv_coord_t obj_h = lv_obj_get_height(obj);
 
@@ -4537,9 +4596,6 @@ static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
         return LV_RES_INV;
     }
     lv_coord_t sb_h = (obj_h * obj_h) / content_h;
-    if(sb_h != 150) {
-        volatile int x = 0;
-    }
     lv_coord_t rem = obj_h - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
     lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
     if(scroll_h <= 0) {
@@ -4561,4 +4617,37 @@ static lv_res_t get_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
     return LV_RES_OK;
 }
 
+static lv_res_t get_hor_scrollbar_area(lv_obj_t * obj, lv_area_t * sbh)
+{
+    lv_coord_t obj_w = lv_obj_get_width(obj);
+
+    lv_area_t child_box;
+    lv_res_t res = lv_obj_get_children_box(obj, &child_box);
+    if(res != LV_RES_OK) return res;
+
+    lv_coord_t content_w = (child_box.x2 - obj->scroll.x) - obj->coords.x1 ;
+    if(content_w < obj_w) {
+        return LV_RES_INV;
+    }
+    lv_coord_t sb_h = (obj_w * obj_w) / content_w;
+    lv_coord_t rem = obj_w - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+    lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
+    if(scroll_w <= 0) {
+        sbh->y2 = obj->coords.y2;
+        sbh->y1 = sbh->y2 - 10;
+        sbh->x2 = obj->coords.x2;
+        sbh->x1 = obj->coords.x1;
+        return LV_RES_OK;
+    }
+    lv_coord_t sb_x = (rem * (child_box.x2 - obj->coords.x2)) / scroll_w;
+    sb_x = rem - sb_x;
+
+    sbh->x1 = obj->coords.x1 + sb_x;
+    sbh->x2 = sbh->x1 + sb_h;
+    sbh->y2 = obj->coords.y2;
+    sbh->y1 = sbh->y2 - 10;
+
+    return LV_RES_OK;
+}
+
 
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index c914616ea..a9acb7bef 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -594,6 +594,24 @@ lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj);
 lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj);
 
 
+/**
+ * Return the weight of the area on the left the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj);
+
+/**
+ * Return the width of the area below the object.
+ * That is the number of pixels the object can be scrolled left.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj);
+
 /**
  * Set the size of an extended clickable area
  * @param obj pointer to an object

From a86e03371f60a642a973efaed9bbdebe21715ec8 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 14 Jul 2020 20:07:49 +0200
Subject: [PATCH 08/84] scroll: handle styles

---
 src/lv_core/lv_obj.c           | 195 +++++++++++++++++++++------------
 src/lv_core/lv_obj.h           |   1 +
 src/lv_core/lv_obj_style_dec.h |  10 ++
 src/lv_core/lv_style.h         |  10 ++
 4 files changed, 145 insertions(+), 71 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 876115330..e47033428 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -48,6 +48,7 @@
 #define LV_OBJX_NAME "lv_obj"
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
+#define SCROLLBAR_MIN_SIZE (LV_DPX(10))
 
 /**********************
  *      TYPEDEFS
@@ -104,8 +105,8 @@ static void refresh_event_task_cb(lv_task_t * t);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
-static lv_res_t get_ver_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv);
-static lv_res_t get_hor_scrollbar_area(lv_obj_t * obj, lv_area_t * sbh);
+static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
+static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor, const lv_area_t * clip_area);
 
 /**********************
  *  STATIC VARIABLES
@@ -3882,25 +3883,22 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             /*Add the mask and use `obj+8` as custom id. Don't use `obj` directly because it might be used by the user*/
             lv_draw_mask_add(mp, obj + 8);
         }
-
-        if(lv_obj_get_screen(obj) == lv_scr_act()) {
-            lv_area_t sb;
-            if(get_ver_scrollbar_area(obj, &sb)) {
-                lv_draw_rect_dsc_t sb_rect_dsc;
-                lv_draw_rect_dsc_init(&sb_rect_dsc);
-                sb_rect_dsc.bg_color = LV_COLOR_RED;
-                lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
-            }
-
-            if(get_hor_scrollbar_area(obj, &sb)) {
-                lv_draw_rect_dsc_t sb_rect_dsc;
-                lv_draw_rect_dsc_init(&sb_rect_dsc);
-                sb_rect_dsc.bg_color = LV_COLOR_BLUE;
-                lv_draw_rect(&sb, clip_area, &sb_rect_dsc);
-            }
-        }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
+
+        if(lv_obj_get_screen(obj) == lv_scr_act()) {
+            lv_draw_rect_dsc_t sb_rect_dsc;
+            lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &sb_rect_dsc);
+            if(sb_res == LV_RES_OK) {
+                lv_area_t hor_area;
+                lv_area_t ver_area;
+                scrollbar_get_area(obj, &hor_area, &ver_area, clip_area);
+
+                lv_draw_rect(&hor_area, clip_area, &sb_rect_dsc);
+                lv_draw_rect(&ver_area, clip_area, &sb_rect_dsc);
+            }
+        }
+
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
             lv_draw_mask_radius_param_t * param = lv_draw_mask_remove_custom(obj + 8);
             _lv_mem_buf_release(param);
@@ -4583,71 +4581,126 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
     return false;
 }
 
-static lv_res_t get_ver_scrollbar_area(lv_obj_t * obj, lv_area_t * sbv)
+static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
 {
-    lv_coord_t obj_h = lv_obj_get_height(obj);
+    lv_draw_rect_dsc_init(dsc);
+    dsc->bg_opa = 100;//lv_obj_get_style_scrollbar_bg_opa(obj, LV_OBJ_PART_MAIN);
+    if(dsc->bg_opa > LV_OPA_MIN) {
+        dsc->bg_color = lv_obj_get_style_scrollbar_bg_color(obj, LV_OBJ_PART_MAIN);
+    }
 
-    lv_area_t child_box;
-    lv_res_t res = lv_obj_get_children_box(obj, &child_box);
-    if(res != LV_RES_OK) return res;
+    dsc->border_opa = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
+    if(dsc->border_opa > LV_OPA_MIN) {
+        dsc->border_width = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
+        if(dsc->border_width > 0) {
+            dsc->border_color = lv_obj_get_style_scrollbar_border_color(obj, LV_OBJ_PART_MAIN);
+        } else {
+            dsc->border_opa = LV_OPA_TRANSP;
+        }
+    }
 
-    lv_coord_t content_h = (child_box.y2 - obj->scroll.y) - obj->coords.y1 ;
-    if(content_h < obj_h) {
+    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP) {
+        dsc->radius = 20;//lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
+        return LV_RES_OK;
+    } else {
         return LV_RES_INV;
     }
-    lv_coord_t sb_h = (obj_h * obj_h) / content_h;
-    lv_coord_t rem = obj_h - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
-    lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
-    if(scroll_h <= 0) {
-        sbv->y1 = obj->coords.y1;
-        sbv->y2 = obj->coords.y2;
-        sbv->x2 = obj->coords.x2;
-        sbv->x1 = sbv->x2 - 10;
-        return LV_RES_OK;
-    }
-    lv_coord_t sb_y = (rem * (child_box.y2 - obj->coords.y2)) / scroll_h;
-    sb_y = rem - sb_y;
-
-
-    sbv->y1 = obj->coords.y1 + sb_y;
-    sbv->y2 = sbv->y1 + sb_h;
-    sbv->x2 = obj->coords.x2;
-    sbv->x1 = sbv->x2 - 10;
-
-    return LV_RES_OK;
 }
 
-static lv_res_t get_hor_scrollbar_area(lv_obj_t * obj, lv_area_t * sbh)
+static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor, const lv_area_t * clip_area)
 {
+    lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t tickness = 10;//lv_obj_get_style_scrollbar_width(obj, LV_OBJ_PART_MAIN);
+
+    lv_coord_t obj_h = lv_obj_get_height(obj);
     lv_coord_t obj_w = lv_obj_get_width(obj);
 
-    lv_area_t child_box;
-    lv_res_t res = lv_obj_get_children_box(obj, &child_box);
-    if(res != LV_RES_OK) return res;
+    lv_coord_t st = lv_obj_get_scroll_top(obj);
+    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
+    lv_coord_t sl = lv_obj_get_scroll_left(obj);
+    lv_coord_t sr = lv_obj_get_scroll_right(obj);
 
-    lv_coord_t content_w = (child_box.x2 - obj->scroll.x) - obj->coords.x1 ;
-    if(content_w < obj_w) {
-        return LV_RES_INV;
+    lv_coord_t ver_reg_space = tickness + side_space;
+    lv_coord_t hor_req_space = tickness + side_space;
+    lv_coord_t rem;
+
+    ver->y1 = obj->coords.y1;
+    ver->y2 = obj->coords.y2;
+    ver->x2 = obj->coords.x2;
+    ver->x1 = ver->x2 - tickness;
+
+    if(_lv_area_is_on(ver, clip_area)) {
+        printf("v\n");
+        lv_coord_t content_h = obj_h + st + sb;
+        lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
+        sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
+        rem = (obj_h - end_space * 2 - hor_req_space) - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
+        if(scroll_h <= 0) {
+            ver->y1 = obj->coords.y1 + end_space;
+            ver->y2 = obj->coords.y2 - end_space - hor_req_space;
+            ver->x2 = obj->coords.x2;
+            ver->x1 = ver->x2 - tickness;
+        } else {
+            lv_coord_t sb_y = (rem * sb) / scroll_h;
+            sb_y = rem - sb_y;
+
+            ver->y1 = obj->coords.y1 + sb_y + end_space;
+            ver->y2 = ver->y1 + sb_h;
+            ver->x2 = obj->coords.x2;
+            ver->x1 = ver->x2 - tickness;
+            if(ver->y1 < obj->coords.y1) {
+                ver->y1 = obj->coords.y1;
+                if(ver->y1 + SCROLLBAR_MIN_SIZE > ver->y2) ver->y2 = ver->y1 + SCROLLBAR_MIN_SIZE;
+            }
+            if(ver->y2 > obj->coords.y2) {
+                ver->y2 = obj->coords.y2;
+                if(ver->y2 - SCROLLBAR_MIN_SIZE < ver->y1) ver->y1 = ver->y2 - SCROLLBAR_MIN_SIZE;
+            }
+        }
+    } else {
+        /*Set an invalid area if not in the clip area*/
+        lv_area_set(ver, -1, -1, -2, -2);
     }
-    lv_coord_t sb_h = (obj_w * obj_w) / content_w;
-    lv_coord_t rem = obj_w - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
-    lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
-    if(scroll_w <= 0) {
-        sbh->y2 = obj->coords.y2;
-        sbh->y1 = sbh->y2 - 10;
-        sbh->x2 = obj->coords.x2;
-        sbh->x1 = obj->coords.x1;
-        return LV_RES_OK;
+
+    hor->y2 = obj->coords.y2;
+    hor->y1 = hor->y2 - tickness;
+    hor->x1 = obj->coords.x1;
+    hor->x2 = obj->coords.x2;
+    if(_lv_area_is_on(hor, clip_area)) {
+        printf("h\n");
+        lv_coord_t content_w = obj_w + sl + sr;
+        lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
+        sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
+        rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
+        if(scroll_w <= 0) {
+            hor->y2 = obj->coords.y2;
+            hor->y1 = hor->y2 - tickness;
+            hor->x1 = obj->coords.x1 + end_space;
+            hor->x2 = obj->coords.x2 - end_space - ver_reg_space;
+        } else {
+            lv_coord_t sb_x = (rem * sr) / scroll_w;
+            sb_x = rem - sb_x;
+
+            hor->x1 = obj->coords.x1 + sb_x + end_space;
+            hor->x2 = hor->x1 + sb_w;
+            hor->y2 = obj->coords.y2;
+            hor->y1 = hor->y2 - tickness;
+            if(hor->x1 < obj->coords.x1) {
+                hor->x1 = obj->coords.x1;
+                if(hor->x1 + SCROLLBAR_MIN_SIZE > hor->x2) hor->x2 = hor->x1 + SCROLLBAR_MIN_SIZE;
+            }
+            if(hor->x2 > obj->coords.x2) {
+                hor->x2 = obj->coords.x2;
+                if(hor->x2 - SCROLLBAR_MIN_SIZE < hor->x1) hor->x1 = hor->x2 - SCROLLBAR_MIN_SIZE;
+            }
+        }
+    } else {
+        /*Set an invalid area if not in the clip area*/
+        lv_area_set(hor, -1, -1, -2, -2);
     }
-    lv_coord_t sb_x = (rem * (child_box.x2 - obj->coords.x2)) / scroll_w;
-    sb_x = rem - sb_x;
-
-    sbh->x1 = obj->coords.x1 + sb_x;
-    sbh->x2 = sbh->x1 + sb_h;
-    sbh->y2 = obj->coords.y2;
-    sbh->y1 = sbh->y2 - 10;
-
-    return LV_RES_OK;
 }
 
 
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index a9acb7bef..f2e01a33f 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -230,6 +230,7 @@ typedef struct _lv_obj_t {
     uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
     uint8_t gesture_parent  : 1; /**< 1: Parent will be gesture instead*/
     uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
+    lv_drag_dir_t scroll_elastic  : 3; /**< In which directions the object can be scrolled */
 
     lv_drag_dir_t drag_dir    : 3; /**< In which directions the object can be dragged */
     lv_drag_dir_t scroll_dir  : 3; /**< In which directions the object can be scrolled */
diff --git a/src/lv_core/lv_obj_style_dec.h b/src/lv_core/lv_obj_style_dec.h
index 47751597e..839005fc9 100644
--- a/src/lv_core/lv_obj_style_dec.h
+++ b/src/lv_core/lv_obj_style_dec.h
@@ -197,6 +197,16 @@ _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_LINE_WIDTH, scale_end_line_width, lv_sty
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_GRAD_COLOR, scale_grad_color, lv_color_t, _color, nonscalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_COLOR, scale_end_color, lv_color_t, _color, nonscalar)
 
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_WIDTH, scrollbar_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_SPACE_SIDE, scrollbar_space_side, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_SPACE_END, scrollbar_space_end, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_RADIUS, scrollbar_radius, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_BORDER_WIDTH, scrollbar_border_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_BG_COLOR, scrollbar_bg_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_BORDER_COLOR, scrollbar_border_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_BG_OPA, scrollbar_bg_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_BORDER_OPA, scrollbar_border_opa, lv_opa_t, _opa, scalar)
+
 #undef _LV_OBJ_STYLE_SET_GET_DECLARE
 
 
diff --git a/src/lv_core/lv_style.h b/src/lv_core/lv_style.h
index 5909299b6..a5602675d 100644
--- a/src/lv_core/lv_style.h
+++ b/src/lv_core/lv_style.h
@@ -197,6 +197,16 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_LINE_WIDTH,   0xC, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_GRAD_COLOR,       0xC, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_COLOR,        0xC, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_WIDTH,            0xD, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_SPACE_SIDE,       0xD, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_SPACE_END,        0xD, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_RADIUS,           0xD, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_BORDER_WIDTH,     0xD, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_BG_COLOR,         0xD, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_BORDER_COLOR,     0xD, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_BG_OPA,           0xD, LV_STYLE_ID_OPA + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_BORDER_OPA,       0xD, LV_STYLE_ID_OPA + 1, LV_STYLE_ATTR_NONE),
 };
 
 typedef uint16_t lv_style_property_t;

From 01a78485aaeaa6589295232cefe5c619c40ffef1 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 16 Jul 2020 13:06:32 +0200
Subject: [PATCH 09/84] scroll: set default style values

---
 src/lv_core/lv_obj.c           | 28 ++++++++++++++--------------
 src/lv_core/lv_obj_style_dec.h |  2 +-
 src/lv_core/lv_style.h         |  2 +-
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index e47033428..5b1c9c068 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1190,7 +1190,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
         child = lv_obj_get_child(obj, child);
     }
 
-    return y2 - obj->coords.y2;
+    return y2 - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
 }
 
 /**
@@ -1226,7 +1226,7 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
         child = lv_obj_get_child(obj, child);
     }
 
-    return x2 - obj->coords.x2;
+    return x2 - obj->coords.x2  + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
 }
 
 /**
@@ -2697,6 +2697,8 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
             return 255;
         case LV_STYLE_TRANSFORM_ZOOM:
             return LV_IMG_ZOOM_NONE;
+        case LV_STYLE_SCROLLBAR_TICKNESS:
+            return LV_DPX(10);
     }
 
     return 0;
@@ -4584,14 +4586,14 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
 {
     lv_draw_rect_dsc_init(dsc);
-    dsc->bg_opa = 100;//lv_obj_get_style_scrollbar_bg_opa(obj, LV_OBJ_PART_MAIN);
+    dsc->bg_opa = lv_obj_get_style_scrollbar_bg_opa(obj, LV_OBJ_PART_MAIN);
     if(dsc->bg_opa > LV_OPA_MIN) {
         dsc->bg_color = lv_obj_get_style_scrollbar_bg_color(obj, LV_OBJ_PART_MAIN);
     }
 
     dsc->border_opa = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
     if(dsc->border_opa > LV_OPA_MIN) {
-        dsc->border_width = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
+        dsc->border_width = lv_obj_get_style_scrollbar_border_width(obj, LV_OBJ_PART_MAIN);
         if(dsc->border_width > 0) {
             dsc->border_color = lv_obj_get_style_scrollbar_border_color(obj, LV_OBJ_PART_MAIN);
         } else {
@@ -4600,7 +4602,7 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
     }
 
     if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP) {
-        dsc->radius = 20;//lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
+        dsc->radius = lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
         return LV_RES_OK;
     } else {
         return LV_RES_INV;
@@ -4611,7 +4613,7 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
 {
     lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
     lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t tickness = 10;//lv_obj_get_style_scrollbar_width(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t tickness = lv_obj_get_style_scrollbar_tickness(obj, LV_OBJ_PART_MAIN);
 
     lv_coord_t obj_h = lv_obj_get_height(obj);
     lv_coord_t obj_w = lv_obj_get_width(obj);
@@ -4631,7 +4633,6 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
     ver->x1 = ver->x2 - tickness;
 
     if(_lv_area_is_on(ver, clip_area)) {
-        printf("v\n");
         lv_coord_t content_h = obj_h + st + sb;
         lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
         sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
@@ -4639,15 +4640,15 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
         lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
         if(scroll_h <= 0) {
             ver->y1 = obj->coords.y1 + end_space;
-            ver->y2 = obj->coords.y2 - end_space - hor_req_space;
+            ver->y2 = obj->coords.y2 - end_space - hor_req_space - 1;
             ver->x2 = obj->coords.x2;
-            ver->x1 = ver->x2 - tickness;
+            ver->x1 = ver->x2 - tickness + 1;
         } else {
             lv_coord_t sb_y = (rem * sb) / scroll_h;
             sb_y = rem - sb_y;
 
             ver->y1 = obj->coords.y1 + sb_y + end_space;
-            ver->y2 = ver->y1 + sb_h;
+            ver->y2 = ver->y1 + sb_h - 1;
             ver->x2 = obj->coords.x2;
             ver->x1 = ver->x2 - tickness;
             if(ver->y1 < obj->coords.y1) {
@@ -4669,7 +4670,6 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
     hor->x1 = obj->coords.x1;
     hor->x2 = obj->coords.x2;
     if(_lv_area_is_on(hor, clip_area)) {
-        printf("h\n");
         lv_coord_t content_w = obj_w + sl + sr;
         lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
         sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
@@ -4677,15 +4677,15 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
         lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
         if(scroll_w <= 0) {
             hor->y2 = obj->coords.y2;
-            hor->y1 = hor->y2 - tickness;
+            hor->y1 = hor->y2 - tickness + 1;
             hor->x1 = obj->coords.x1 + end_space;
-            hor->x2 = obj->coords.x2 - end_space - ver_reg_space;
+            hor->x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
         } else {
             lv_coord_t sb_x = (rem * sr) / scroll_w;
             sb_x = rem - sb_x;
 
             hor->x1 = obj->coords.x1 + sb_x + end_space;
-            hor->x2 = hor->x1 + sb_w;
+            hor->x2 = hor->x1 + sb_w - 1;
             hor->y2 = obj->coords.y2;
             hor->y1 = hor->y2 - tickness;
             if(hor->x1 < obj->coords.x1) {
diff --git a/src/lv_core/lv_obj_style_dec.h b/src/lv_core/lv_obj_style_dec.h
index 839005fc9..8876412c3 100644
--- a/src/lv_core/lv_obj_style_dec.h
+++ b/src/lv_core/lv_obj_style_dec.h
@@ -197,7 +197,7 @@ _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_LINE_WIDTH, scale_end_line_width, lv_sty
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_GRAD_COLOR, scale_grad_color, lv_color_t, _color, nonscalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_COLOR, scale_end_color, lv_color_t, _color, nonscalar)
 
-_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_WIDTH, scrollbar_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_TICKNESS, scrollbar_tickness, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_SPACE_SIDE, scrollbar_space_side, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_SPACE_END, scrollbar_space_end, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(SCROLLBAR_RADIUS, scrollbar_radius, lv_style_int_t, _int, scalar)
diff --git a/src/lv_core/lv_style.h b/src/lv_core/lv_style.h
index a5602675d..5af62ec3f 100644
--- a/src/lv_core/lv_style.h
+++ b/src/lv_core/lv_style.h
@@ -198,7 +198,7 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_GRAD_COLOR,       0xC, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_COLOR,        0xC, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
 
-    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_WIDTH,            0xD, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_TICKNESS,            0xD, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_SPACE_SIDE,       0xD, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_SPACE_END,        0xD, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCROLLBAR_RADIUS,           0xD, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),

From 5cce6daa4a2fb38fbe04ea7ea6198a271220963b Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 21 Jul 2020 21:09:33 +0200
Subject: [PATCH 10/84] scroll: remove drag

---
 src/lv_core/lv_indev.c       | 493 +++++++++++------------------------
 src/lv_core/lv_indev.h       |  20 +-
 src/lv_core/lv_obj.c         | 120 ++-------
 src/lv_core/lv_obj.h         | 119 +++------
 src/lv_hal/lv_hal_indev.c    |   4 +-
 src/lv_hal/lv_hal_indev.h    |  24 +-
 src/lv_widgets/lv_btn.c      |   2 +-
 src/lv_widgets/lv_cpicker.c  |   4 +-
 src/lv_widgets/lv_dropdown.c |   6 +-
 src/lv_widgets/lv_list.c     |   4 +-
 src/lv_widgets/lv_page.c     |   2 +-
 src/lv_widgets/lv_roller.c   |   2 +-
 src/lv_widgets/lv_tileview.c |   4 +-
 13 files changed, 222 insertions(+), 582 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index a415dc1ec..2be5474d9 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -40,9 +40,8 @@ static void indev_proc_press(lv_indev_proc_t * proc);
 static void indev_proc_release(lv_indev_proc_t * proc);
 static void indev_proc_reset_query_handler(lv_indev_t * indev);
 static void indev_click_focus(lv_indev_proc_t * proc);
-static void indev_drag(lv_indev_proc_t * proc);
-static void indev_drag_throw(lv_indev_proc_t * proc);
-static lv_obj_t * get_dragged_obj(lv_obj_t * obj);
+static void indev_scroll_handler(lv_indev_proc_t * proc);
+static void indev_scroll_throw_handler(lv_indev_proc_t * proc);
 static void indev_gesture(lv_indev_proc_t * proc);
 static bool indev_reset_check(lv_indev_proc_t * proc);
 
@@ -288,20 +287,21 @@ uint32_t lv_indev_get_key(const lv_indev_t * indev)
 }
 
 /**
- * Check if there is dragging with an input device or not (for LV_INDEV_TYPE_POINTER and
+ * Check the current scroll direction of an input device (for LV_INDEV_TYPE_POINTER and
  * LV_INDEV_TYPE_BUTTON)
  * @param indev pointer to an input device
- * @return true: drag is in progress
+ * @return LV_SCROLL_DIR_NONE: no scrolling now
+ *         LV_SCROLL_DIR_HOR/VER
  */
-bool lv_indev_is_dragging(const lv_indev_t * indev)
+lv_scroll_dir_t lv_indev_get_scroll_dir(const lv_indev_t * indev)
 {
     if(indev == NULL) return false;
     if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) return false;
-    return indev->proc.types.pointer.drag_in_prog == 0 ? false : true;
+    return indev->proc.types.pointer.scroll_dir;
 }
 
 /**
- * Get the types.pointer.vector of dragging of an input device (for LV_INDEV_TYPE_POINTER and
+ * Get the movement vector 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 types.pointer.vector
@@ -324,36 +324,6 @@ void lv_indev_get_vect(const lv_indev_t * indev, lv_point_t * point)
     }
 }
 
-/**
- * Manually finish dragging.
- * `LV_SIGNAL_DRAG_END` and `LV_EVENT_DRAG_END` will be sent.
- * @param indev pointer to an input device
- * @return `LV_RES_INV` if the object being dragged was deleted. Else `LV_RES_OK`.
- */
-lv_res_t lv_indev_finish_drag(lv_indev_t * indev)
-{
-    if(indev == NULL) return LV_RES_OK;
-    if(indev->driver.type != LV_INDEV_TYPE_POINTER) return LV_RES_OK;
-    if(indev->proc.types.pointer.drag_in_prog == 0) return LV_RES_OK;
-
-    indev->proc.types.pointer.drag_in_prog = 0;
-    indev->proc.types.pointer.drag_throw_vect.x = 0;
-    indev->proc.types.pointer.drag_throw_vect.y = 0;
-
-    lv_obj_t * drag_obj;
-    drag_obj = get_dragged_obj(indev->proc.types.pointer.act_obj);
-    if(drag_obj == NULL) return LV_RES_OK;
-
-    lv_res_t res;
-    res = drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_END, NULL);
-    if(res != LV_RES_OK) return res;
-
-    res = lv_event_send(drag_obj, LV_EVENT_DRAG_END, NULL);
-    if(res != LV_RES_OK) return res;
-
-    return res;
-}
-
 /**
  * Do nothing until the next release
  * @param indev pointer to an input device
@@ -846,8 +816,8 @@ static void indev_proc_press(lv_indev_proc_t * proc)
                                                                           &proc->types.pointer.act_point);
         new_obj_searched = true;
     }
-    /*If there is last object but it is not dragged and not protected also search*/
-    else if(proc->types.pointer.drag_in_prog == 0 &&
+    /*If there is last object but it is not scrolled and not protected also search*/
+    else if(proc->types.pointer.scroll_obj == NULL &&
             lv_obj_is_protected(indev_obj_act, LV_PROTECT_PRESS_LOST) == false) {
         indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_sys(disp), &proc->types.pointer.act_point);
         if(indev_obj_act == NULL) indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_top(disp),
@@ -856,15 +826,12 @@ static void indev_proc_press(lv_indev_proc_t * proc)
                                                                           &proc->types.pointer.act_point);
         new_obj_searched = true;
     }
-    /*If a draggable or a protected object was the last then keep it*/
-    else {
-    }
 
-    /*The last object might have drag throw. Stop it manually*/
+    /*The last object might have scroll throw. Stop it manually*/
     if(new_obj_searched && proc->types.pointer.last_obj) {
-        proc->types.pointer.drag_throw_vect.x = 0;
-        proc->types.pointer.drag_throw_vect.y = 0;
-        indev_drag_throw(proc);
+        proc->types.pointer.scroll_throw_vect.x = 0;
+        proc->types.pointer.scroll_throw_vect.y = 0;
+        indev_scroll_throw_handler(proc);
     }
 
     /*Do not use disabled objects*/
@@ -882,11 +849,10 @@ static void indev_proc_press(lv_indev_proc_t * proc)
             /*Save the obj because in special cases `act_obj` can change in the signal function*/
             lv_obj_t * last_obj = proc->types.pointer.act_obj;
 
-            last_obj->signal_cb(last_obj, LV_SIGNAL_PRESS_LOST, indev_act);
+            lv_signal_send(last_obj, LV_SIGNAL_PRESS_LOST, indev_act);
             if(indev_reset_check(proc)) return;
             lv_event_send(last_obj, LV_EVENT_PRESS_LOST, NULL);
             if(indev_reset_check(proc)) return;
-
         }
 
         proc->types.pointer.act_obj  = indev_obj_act; /*Save the pressed object*/
@@ -896,11 +862,9 @@ static void indev_proc_press(lv_indev_proc_t * proc)
             /* Save the time when the obj pressed to count long press time.*/
             proc->pr_timestamp                 = lv_tick_get();
             proc->long_pr_sent                 = 0;
-            proc->types.pointer.drag_limit_out = 0;
-            proc->types.pointer.drag_in_prog   = 0;
-            proc->types.pointer.drag_sum.x     = 0;
-            proc->types.pointer.drag_sum.y     = 0;
-            proc->types.pointer.drag_dir = LV_DRAG_DIR_BOTH;
+            proc->types.pointer.scroll_sum.x     = 0;
+            proc->types.pointer.scroll_sum.y     = 0;
+            proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
             proc->types.pointer.gesture_sent   = 0;
             proc->types.pointer.gesture_sum.x  = 0;
             proc->types.pointer.gesture_sum.y  = 0;
@@ -921,7 +885,7 @@ static void indev_proc_press(lv_indev_proc_t * proc)
             }
 
             /*Send a signal about the press*/
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSED, indev_act);
+            lv_signal_send(indev_obj_act, LV_SIGNAL_PRESSED, indev_act);
             if(indev_reset_check(proc)) return;
 
             lv_event_send(indev_obj_act, LV_EVENT_PRESSED, NULL);
@@ -936,33 +900,33 @@ static void indev_proc_press(lv_indev_proc_t * proc)
         }
     }
 
-    /*Calculate the types.pointer.vector*/
+    /*Calculate the vector and apply a low pass filter: new value = 0.5 * old_value + 0.5 * new_value*/
     proc->types.pointer.vect.x = proc->types.pointer.act_point.x - proc->types.pointer.last_point.x;
     proc->types.pointer.vect.y = proc->types.pointer.act_point.y - proc->types.pointer.last_point.y;
 
-    proc->types.pointer.drag_throw_vect.x = (proc->types.pointer.drag_throw_vect.x * 4) >> 3;
-    proc->types.pointer.drag_throw_vect.y = (proc->types.pointer.drag_throw_vect.y * 4) >> 3;
+    proc->types.pointer.scroll_throw_vect.x = (proc->types.pointer.scroll_throw_vect.x * 4) >> 3;
+    proc->types.pointer.scroll_throw_vect.y = (proc->types.pointer.scroll_throw_vect.y * 4) >> 3;
 
-    proc->types.pointer.drag_throw_vect.x += (proc->types.pointer.vect.x * 4) >> 3;
-    proc->types.pointer.drag_throw_vect.y += (proc->types.pointer.vect.y * 4) >> 3;
+    proc->types.pointer.scroll_throw_vect.x += (proc->types.pointer.vect.x * 4) >> 3;
+    proc->types.pointer.scroll_throw_vect.y += (proc->types.pointer.vect.y * 4) >> 3;
 
-    /*If there is active object and it can be dragged run the drag*/
-    if(indev_obj_act != NULL) {
-        indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSING, indev_act);
+    if(indev_obj_act) {
+        lv_signal_send(indev_obj_act, LV_SIGNAL_PRESSING, indev_act);
         if(indev_reset_check(proc)) return;
         lv_event_send(indev_obj_act, LV_EVENT_PRESSING, NULL);
         if(indev_reset_check(proc)) return;
+
         if(indev_act->proc.wait_until_release) return;
 
-        indev_drag(proc);
+        indev_scroll_handler(proc);
         indev_gesture(proc);
         if(indev_reset_check(proc)) return;
 
-        /*If there is no drag then check for long press time*/
-        if(proc->types.pointer.drag_in_prog == 0 && proc->long_pr_sent == 0) {
+        /*If there is no scrolling then check for long press time*/
+        if(proc->types.pointer.scroll_obj == NULL && proc->long_pr_sent == 0) {
             /*Send a signal about the long press if enough time elapsed*/
             if(lv_tick_elaps(proc->pr_timestamp) > indev_act->driver.long_press_time) {
-                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS, indev_act);
+                lv_signal_send(indev_obj_act, LV_SIGNAL_LONG_PRESS, indev_act);
                 if(indev_reset_check(proc)) return;
                 lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED, NULL);
                 if(indev_reset_check(proc)) return;
@@ -974,11 +938,12 @@ static void indev_proc_press(lv_indev_proc_t * proc)
                 proc->longpr_rep_timestamp = lv_tick_get();
             }
         }
+
         /*Send long press repeated signal*/
-        if(proc->types.pointer.drag_in_prog == 0 && proc->long_pr_sent == 1) {
+        if(proc->types.pointer.scroll_obj == NULL && proc->long_pr_sent == 1) {
             /*Send a signal about the long press repeat if enough time elapsed*/
             if(lv_tick_elaps(proc->longpr_rep_timestamp) > indev_act->driver.long_press_rep_time) {
-                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS_REP, indev_act);
+                lv_signal_send(indev_obj_act, LV_SIGNAL_LONG_PRESS_REP, indev_act);
                 if(indev_reset_check(proc)) return;
                 lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED_REPEAT, NULL);
                 if(indev_reset_check(proc)) return;
@@ -1002,73 +967,49 @@ static void indev_proc_release(lv_indev_proc_t * proc)
         proc->wait_until_release     = 0;
     }
     indev_obj_act = proc->types.pointer.act_obj;
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
 
     /*Forget the act obj and send a released signal */
     if(indev_obj_act) {
 
-        /* If the object was protected against press lost then it possible that
-         * the object is already not pressed but still it is the `act_obj`.
-         * In this case send the `LV_SIGNAL_RELEASED/CLICKED` instead of `LV_SIGNAL_PRESS_LOST` if
-         * the indev is ON the `types.pointer.act_obj` */
-        if(lv_obj_is_protected(indev_obj_act, LV_PROTECT_PRESS_LOST)) {
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, indev_act);
-            if(indev_reset_check(proc)) return;
-
-            if(proc->types.pointer.drag_in_prog == 0) {
-                if(proc->long_pr_sent == 0) {
-                    lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
-                    if(indev_reset_check(proc)) return;
-                }
-
-                lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
-                if(indev_reset_check(proc)) return;
-            }
-
-            lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
-            if(indev_reset_check(proc)) return;
-        }
-        /* The simple case: `act_obj` was not protected against press lost.
-         * If it is already not pressed then `indev_proc_press` would set `indev_obj_act = NULL`*/
-        else {
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, indev_act);
-            if(indev_reset_check(proc)) return;
-
-            if(proc->long_pr_sent == 0 && proc->types.pointer.drag_in_prog == 0) {
+        /*Send CLICK if no scrolling*/
+        if(scroll_obj == NULL) {
+            if(proc->long_pr_sent == 0) {
                 lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
                 if(indev_reset_check(proc)) return;
             }
 
-            if(proc->types.pointer.drag_in_prog == 0) {
-                lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
-                if(indev_reset_check(proc)) return;
-            }
-
-            lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
+            lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
             if(indev_reset_check(proc)) return;
         }
 
-        /*Send LV_EVENT_DRAG_THROW_BEGIN if required */
-        /*If drag parent is active check recursively the drag_parent attribute*/
-        lv_obj_t * drag_obj = get_dragged_obj(indev_obj_act);
-        if(drag_obj) {
-            if(lv_obj_get_drag_throw(drag_obj) && proc->types.pointer.drag_in_prog) {
-                if(drag_obj->signal_cb) drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_THROW_BEGIN, NULL);
-                if(indev_reset_check(proc)) return;
+        /*Send RELEASE signal and event*/
+        lv_signal_send(indev_obj_act, LV_SIGNAL_RELEASED, indev_act);
+        if(indev_reset_check(proc)) return;
 
-                lv_event_send(drag_obj, LV_EVENT_DRAG_THROW_BEGIN, NULL);
-                if(indev_reset_check(proc)) return;
-            }
+        lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
+        if(indev_reset_check(proc)) return;
+
+
+        /*Send SCROLL_THROW_BEGIN signal and event*/
+        if(scroll_obj) {
+            lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_THROW_BEGIN, indev_act);
+            if(indev_reset_check(proc)) return;
+
+            lv_event_send(indev_obj_act, LV_EVENT_SCROLL_THROW_BEGIN, indev_act);
+            if(indev_reset_check(proc)) return;
         }
 
         proc->types.pointer.act_obj = NULL;
         proc->pr_timestamp          = 0;
         proc->longpr_rep_timestamp  = 0;
+
     }
 
     /*The reset can be set in the signal function.
      * In case of reset query ignore the remaining parts.*/
-    if(proc->types.pointer.last_obj != NULL && proc->reset_query == 0) {
-        indev_drag_throw(proc);
+    if(scroll_obj) {
+        indev_scroll_throw_handler(proc);
         if(indev_reset_check(proc)) return;
     }
 }
@@ -1085,17 +1026,15 @@ static void indev_proc_reset_query_handler(lv_indev_t * indev)
     if(indev->proc.reset_query) {
         indev->proc.types.pointer.act_obj           = NULL;
         indev->proc.types.pointer.last_obj          = NULL;
-        indev->proc.types.pointer.drag_obj          = NULL;
-        indev->proc.types.pointer.drag_limit_out    = 0;
-        indev->proc.types.pointer.drag_in_prog      = 0;
+        indev->proc.types.pointer.scroll_obj          = NULL;
         indev->proc.long_pr_sent                    = 0;
         indev->proc.pr_timestamp                    = 0;
         indev->proc.longpr_rep_timestamp            = 0;
-        indev->proc.types.pointer.drag_sum.x        = 0;
-        indev->proc.types.pointer.drag_sum.y        = 0;
-        indev->proc.types.pointer.drag_dir = LV_DRAG_DIR_BOTH;
-        indev->proc.types.pointer.drag_throw_vect.x = 0;
-        indev->proc.types.pointer.drag_throw_vect.y = 0;
+        indev->proc.types.pointer.scroll_sum.x        = 0;
+        indev->proc.types.pointer.scroll_sum.y        = 0;
+        indev->proc.types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
+        indev->proc.types.pointer.scroll_throw_vect.x = 0;
+        indev->proc.types.pointer.scroll_throw_vect.y = 0;
         indev->proc.types.pointer.gesture_sum.x     = 0;
         indev->proc.types.pointer.gesture_sum.y     = 0;
         indev->proc.reset_query                     = 0;
@@ -1237,42 +1176,30 @@ static void indev_click_focus(lv_indev_proc_t * proc)
 }
 
 /**
- * Handle the dragging of indev_proc_p->types.pointer.act_obj
+ * Handle the scrolling
  * @param indev pointer to a input device state
  */
-static void indev_drag(lv_indev_proc_t * proc)
+static void indev_scroll_handler(lv_indev_proc_t * proc)
 {
-    bool scrollable = true;
-
-    lv_coord_t act_x = 0;
-    lv_coord_t act_y = 0;
     lv_obj_t * scroll_candidate_obj = NULL;
-    lv_drag_dir_t dirs_candidate = LV_DRAG_DIR_NONE;
+    lv_scroll_dir_t dirs_candidate = LV_SCROLL_DIR_NONE;
 
-    /*Count the movement by drag*/
-    if(proc->types.pointer.drag_limit_out == 0) {
-        proc->types.pointer.drag_sum.x += proc->types.pointer.vect.x;
-        proc->types.pointer.drag_sum.y += proc->types.pointer.vect.y;
+    /*If there is no scroll object yet try to find one*/
+    if(proc->types.pointer.scroll_obj == NULL) {
+        proc->types.pointer.scroll_sum.x += proc->types.pointer.vect.x;
+        proc->types.pointer.scroll_sum.y += proc->types.pointer.vect.y;
 
-        proc->types.pointer.drag_obj = proc->types.pointer.act_obj;
+        proc->types.pointer.scroll_obj = proc->types.pointer.act_obj;
 
-        /*Go until find the object or parent scrollable in this direction*/
-        while(proc->types.pointer.drag_obj) {
-            /*Get which object to drad/scroll*/
-            lv_drag_dir_t dirs = LV_DRAG_DIR_ONE; //scrollable ? lv_obj_get_scroll_dir(target_obj) : lv_obj_get_drag_dir(target_obj);
-
-            /*Enough move?*/
+        /*Go until find an scrollable object in the current direction*/
+        while(proc->types.pointer.scroll_obj) {
             bool hor_en = false;
             bool ver_en = false;
-            if(dirs == LV_DRAG_DIR_HOR || dirs == LV_DRAG_DIR_BOTH) hor_en = true;
-            if(dirs == LV_DRAG_DIR_VER || dirs == LV_DRAG_DIR_BOTH) ver_en = true;
-            if(dirs == LV_DRAG_DIR_ONE) {
-                if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
-                    hor_en = true;
-                }
-                else {
-                    ver_en = true;
-                }
+            if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
+                hor_en = true;
+            }
+            else {
+                ver_en = true;
             }
 
             bool up_en = ver_en;
@@ -1280,28 +1207,28 @@ static void indev_drag(lv_indev_proc_t * proc)
             bool left_en = hor_en;
             bool right_en = hor_en;
 
-            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.drag_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.drag_obj);
-            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.drag_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.drag_obj);
+            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.scroll_obj);
+            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.scroll_obj);
 
             bool ver_scrollable = st > 0 || sb > 0 ? true : false;
             bool hor_scrollable = sl > 0 || sr > 0 ? true : false;
 
             if(ver_scrollable &&
-               ((up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
-                (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit)))
+               ((up_en    && proc->types.pointer.scroll_sum.y >=   indev_act->driver.scroll_limit) ||
+                (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit)))
             {
-                scroll_candidate_obj = proc->types.pointer.drag_obj;
-                dirs_candidate = LV_DRAG_DIR_VER;
+                scroll_candidate_obj = proc->types.pointer.scroll_obj;
+                dirs_candidate = LV_SCROLL_DIR_VER;
             }
 
             if(hor_scrollable &&
-              ((left_en    && proc->types.pointer.drag_sum.x >=   indev_act->driver.drag_limit) ||
-               (right_en  && proc->types.pointer.drag_sum.x <= - indev_act->driver.drag_limit)))
+              ((left_en    && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
+               (right_en  && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit)))
             {
-                scroll_candidate_obj = proc->types.pointer.drag_obj;
-                dirs_candidate = LV_DRAG_DIR_HOR;
+                scroll_candidate_obj = proc->types.pointer.scroll_obj;
+                dirs_candidate = LV_SCROLL_DIR_HOR;
             }
 
             if(st <= 0) up_en = false;
@@ -1309,236 +1236,106 @@ static void indev_drag(lv_indev_proc_t * proc)
             if(sl <= 0) left_en = false;
             if(sr <= 0) right_en = false;
 
-
-            /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
-            if((left_en  && proc->types.pointer.drag_sum.x >=   indev_act->driver.drag_limit) ||
-               (right_en && proc->types.pointer.drag_sum.x <= - indev_act->driver.drag_limit) ||
-               (up_en    && proc->types.pointer.drag_sum.y >=   indev_act->driver.drag_limit) ||
-               (down_en  && proc->types.pointer.drag_sum.y <= - indev_act->driver.drag_limit))
+            if((left_en  && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
+               (right_en && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit) ||
+               (up_en    && proc->types.pointer.scroll_sum.y >=   indev_act->driver.scroll_limit) ||
+               (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit))
             {
-                proc->types.pointer.drag_limit_out = 1;
-                if(dirs == LV_DRAG_DIR_ONE) {
-                    proc->types.pointer.drag_dir = hor_en ? LV_DRAG_DIR_HOR : LV_DRAG_DIR_VER;
-                } else {
-                    proc->types.pointer.drag_dir = dirs;
-                }
+                proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
 
-                /*The was no move due to drag limit. Compensate it now.*/
-                if(!hor_en)  proc->types.pointer.drag_sum.x = 0;
-                if(!ver_en)  proc->types.pointer.drag_sum.y = 0;
+                if(!hor_en)  proc->types.pointer.scroll_sum.x = 0;
+                if(!ver_en)  proc->types.pointer.scroll_sum.y = 0;
 
-                act_x = lv_obj_get_x(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.x;
-                act_y = lv_obj_get_y(proc->types.pointer.drag_obj) + proc->types.pointer.drag_sum.y;
-                break;
+                break;  /*It"s good scrollable object, use it*/
             }
-            proc->types.pointer.drag_obj = lv_obj_get_parent(proc->types.pointer.drag_obj);
+            proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
         }
     }
 
-    /*If the drag/scroll can't be propagated to any parent show an elastic scroll in the original object*/
-    if(proc->types.pointer.drag_obj == NULL) {
+    if(proc->types.pointer.scroll_obj == NULL) {
         if(scroll_candidate_obj) {
-            proc->types.pointer.drag_limit_out = 1;
-            proc->types.pointer.drag_dir = dirs_candidate;
-            proc->types.pointer.drag_obj = scroll_candidate_obj;
+            proc->types.pointer.scroll_dir = dirs_candidate;
+            proc->types.pointer.scroll_obj = scroll_candidate_obj;
         } else {
             return;
         }
     }
 
-    lv_obj_t * obj = proc->types.pointer.drag_obj;
+    /*If there is no scroll object there is nothing to do*/
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
+    if(scroll_obj == NULL) return;
 
-    /*If the drag limit is exceeded handle the dragging*/
-    if(proc->types.pointer.drag_limit_out != 0) {
-        /*Set new position or scroll if the vector is not zero*/
-        if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
-
-            lv_coord_t prev_x     = obj->coords.x1;
-            lv_coord_t prev_y     = obj->coords.y1;
-
-            /*Move the object. `drag_sum` is zerod out for *disabled direction*/
-            if(proc->types.pointer.drag_sum.x) act_x += proc->types.pointer.vect.x;
-            if(proc->types.pointer.drag_sum.y) act_y += proc->types.pointer.vect.y;
-
-            uint16_t inv_buf_size =
-                lv_disp_get_inv_buf_size(indev_act->driver.disp); /*Get the number of currently invalidated areas*/
-
-            if(scrollable) {
-                lv_area_t child_box;
-                lv_obj_get_children_box(obj, &child_box);
-                lv_coord_t diff_y = proc->types.pointer.drag_dir == LV_DRAG_DIR_VER ? proc->types.pointer.vect.y : 0;
-                lv_coord_t diff_x = proc->types.pointer.drag_dir == LV_DRAG_DIR_HOR ? proc->types.pointer.vect.x : 0;
-                if(obj->scroll.x > 0 && diff_x > 0) {
-                    diff_x = diff_x / 2;
-                }
-                if(child_box.y2 < obj->coords.y2 && diff_y < 0) {
-                    diff_y = diff_y / 2;
-                }
-
-                lv_obj_scroll_by(obj, diff_x, diff_y, LV_ANIM_OFF);
-            } else {
-                lv_obj_set_pos(obj, act_x, act_y);
-            }
-
-            proc->types.pointer.drag_in_prog = 1;
-//
-//            /*If the object didn't moved then clear the invalidated areas*/
-//            if(target_obj->coords.x1 == prev_x && target_obj->coords.y1 == prev_y) {
-//                /*In a special case if the object is moved on a page and
-//                 * the scrollable has fit == true and the object is dragged of the page then
-//                 * while its coordinate is not changing only the parent's size is reduced */
-//                lv_coord_t act_par_w = lv_obj_get_width(lv_obj_get_parent(target_obj));
-//                lv_coord_t act_par_h = lv_obj_get_height(lv_obj_get_parent(target_obj));
-//                if(act_par_w == prev_par_w && act_par_h == prev_par_h) {
-//                    uint16_t new_inv_buf_size = lv_disp_get_inv_buf_size(indev_act->driver.disp);
-//                    _lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
-//                }
-//            }
-//
-//            /*Set the drag in progress flag*/
-//            /*Send the drag begin signal on first move*/
-//            if(just_started) {
-//                target_obj->signal_cb(target_obj, LV_SIGNAL_DRAG_BEGIN, indev_act);
-//                if(indev_reset_check(proc)) return;
-//
-//                lv_event_send(target_obj, LV_EVENT_DRAG_BEGIN, NULL);
-//                if(indev_reset_check(proc)) return;
-//            }
+    /*Set new position or scroll if the vector is not zero*/
+    if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
+        lv_coord_t diff_x = 0;
+        lv_coord_t diff_y = 0;
 
+        if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
+            diff_x = proc->types.pointer.vect.x;
+            if(lv_obj_get_scroll_right(scroll_obj) < 0) diff_x = diff_x / 2;
+            if(lv_obj_get_scroll_left(scroll_obj) < 0) diff_x = diff_x / 2;
+        } else {
+            diff_y = proc->types.pointer.vect.y;
+            if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
+            if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
         }
+        lv_obj_scroll_by(scroll_obj, diff_x, diff_y, LV_ANIM_OFF);
     }
 }
 
 /**
- * Handle throwing by drag if the drag is ended
+ * Handle throwing by after scrolling
  * @param indev pointer to an input device state
  */
-static void indev_drag_throw(lv_indev_proc_t * proc)
+static void indev_scroll_throw_handler(lv_indev_proc_t * proc)
 {
-    if(proc->types.pointer.drag_in_prog == 0) return;
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
 
-
-    bool scrollable = true;
-
-    /*Get which object to drad/scroll*/
-    lv_obj_t * target_obj = proc->types.pointer.drag_obj;
-    if(target_obj == NULL) return;
-
-    /*Return if the drag throw is not enabled*/
-//    if(lv_obj_get_drag_throw(target_obj) == false) {
-//        proc->types.pointer.drag_in_prog = 0;
-//        target_obj->signal_cb(target_obj, scrollable ? LV_SIGNAL_SCROLL_END : LV_SIGNAL_DRAG_END, indev_act);
-//        if(indev_reset_check(proc)) return;
-//
-//        lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
-//        return;
-//    }
+    if(scroll_obj == NULL) return;
+    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) return;
 
     /*Reduce the vectors*/
-    proc->types.pointer.drag_throw_vect.x =
-        proc->types.pointer.drag_throw_vect.x * (100 - indev_act->driver.drag_throw) / 100;
-    proc->types.pointer.drag_throw_vect.y =
-        proc->types.pointer.drag_throw_vect.y * (100 - indev_act->driver.drag_throw) / 100;
+    proc->types.pointer.scroll_throw_vect.x =
+        proc->types.pointer.scroll_throw_vect.x * (100 - indev_act->driver.scroll_throw) / 100;
+    proc->types.pointer.scroll_throw_vect.y =
+        proc->types.pointer.scroll_throw_vect.y * (100 - indev_act->driver.scroll_throw) / 100;
 
-    switch(proc->types.pointer.drag_dir) {
-        case LV_DRAG_DIR_HOR:
+    switch(proc->types.pointer.scroll_dir) {
+        case LV_SCROLL_DIR_HOR:
         {
-            proc->types.pointer.drag_throw_vect.y = 0;
-            lv_coord_t sl = lv_obj_get_scroll_left(target_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(target_obj);
+            proc->types.pointer.scroll_throw_vect.y = 0;
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
             /*If scrolled inside reduce faster*/
-            if(sl < 0 || sr < 0) proc->types.pointer.drag_throw_vect.x = proc->types.pointer.drag_throw_vect.x >> 1;
+            if(sl < 0 || sr < 0) proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
             break;
         }
-        case LV_DRAG_DIR_VER:
+        case LV_SCROLL_DIR_VER:
         {
-            proc->types.pointer.drag_throw_vect.x = 0;
-            lv_coord_t st = lv_obj_get_scroll_top(target_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(target_obj);
+            proc->types.pointer.scroll_throw_vect.x = 0;
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
             /*If scrolled inside reduce faster*/
-            if(st < 0 || sb < 0) proc->types.pointer.drag_throw_vect.y = proc->types.pointer.drag_throw_vect.y >> 1;
+            if(st < 0 || sb < 0) proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
             break;
         }
     }
 
-    if((proc->types.pointer.drag_throw_vect.x != 0 || proc->types.pointer.drag_throw_vect.y != 0)) {
-        /*Get the coordinates and modify them*/
-        if(scrollable) {
-            lv_obj_scroll_by(target_obj, proc->types.pointer.drag_throw_vect.x, proc->types.pointer.drag_throw_vect.y, LV_ANIM_OFF);
-        } else {
-            lv_area_t coords_ori;
-            lv_obj_get_coords(target_obj, &coords_ori);
-
-            lv_coord_t act_x = lv_obj_get_x(target_obj) + proc->types.pointer.drag_throw_vect.x;
-            lv_coord_t act_y = lv_obj_get_y(target_obj) + proc->types.pointer.drag_throw_vect.y;
-            lv_obj_set_pos(target_obj, act_x, act_y);
-
-            lv_area_t coords_new;
-            lv_obj_get_coords(target_obj, &coords_new);
-
-            /*If non of the coordinates are changed then do not continue throwing*/
-            if((coords_ori.x1 == coords_new.x1 || proc->types.pointer.drag_throw_vect.x == 0) &&
-                    (coords_ori.y1 == coords_new.y1 || proc->types.pointer.drag_throw_vect.y == 0)) {
-                proc->types.pointer.drag_in_prog      = 0;
-                proc->types.pointer.vect.x            = 0;
-                proc->types.pointer.vect.y            = 0;
-                proc->types.pointer.drag_throw_vect.x = 0;
-                proc->types.pointer.drag_throw_vect.y = 0;
-                target_obj->signal_cb(target_obj, LV_SIGNAL_DRAG_END, indev_act);
-                if(indev_reset_check(proc)) return;
-
-                lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
-                if(indev_reset_check(proc)) return;
-            }
-
-        }
-
+    if((proc->types.pointer.scroll_throw_vect.x != 0 || proc->types.pointer.scroll_throw_vect.y != 0)) {
+        lv_obj_scroll_by(scroll_obj, proc->types.pointer.scroll_throw_vect.x, proc->types.pointer.scroll_throw_vect.y, LV_ANIM_OFF);
     }
-    /*If the types.pointer.vectors become 0 -> types.pointer.drag_in_prog = 0 and send a drag end
+    /*If the vectors become 0 then finish scrolling
        signal*/
     else {
-        proc->types.pointer.drag_in_prog = 0;
-        proc->types.pointer.drag_obj = NULL;
-        target_obj->signal_cb(target_obj, scrollable ? LV_SIGNAL_SCROLL_END : LV_SIGNAL_DRAG_END, indev_act);
+        proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
+        proc->types.pointer.scroll_obj = NULL;
+        lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_END, indev_act);
         if(indev_reset_check(proc)) return;
-        lv_event_send(target_obj, LV_EVENT_DRAG_END, NULL);
+        lv_event_send(scroll_obj, LV_EVENT_SCROLL_END, indev_act);
         if(indev_reset_check(proc)) return;
     }
 }
 
-
-/**
- * Get the really dragged object by taking `drag_parent` into account.
- * @param obj the start object
- * @return the object to really drag
- */
-static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
-{
-    return obj;
-
-    if(indev_act->proc.types.pointer.drag_obj) {
-        return indev_act->proc.types.pointer.drag_obj;
-    } else {
-        lv_area_t child_box;
-        lv_obj_get_children_box(obj, &child_box);
-        if(child_box.y2 == obj->coords.y2) indev_act->proc.types.pointer.drag_obj = lv_obj_get_parent(obj);
-        else indev_act->proc.types.pointer.drag_obj = obj;
-    }
-
-    return indev_act->proc.types.pointer.drag_obj;
-
-
-    if(obj == NULL) return NULL;
-    lv_obj_t * drag_obj = obj;
-    while(lv_obj_get_drag_parent(drag_obj) != false && drag_obj != NULL) {
-        drag_obj = lv_obj_get_parent(drag_obj);
-    }
-
-    if(lv_obj_get_drag(drag_obj) == false) return NULL;
-    return drag_obj;
-}
-
-
 /**
 * Handle the gesture of indev_proc_p->types.pointer.act_obj
 * @param indev pointer to a input device state
@@ -1546,7 +1343,7 @@ static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
 static void indev_gesture(lv_indev_proc_t * proc)
 {
 
-    if(proc->types.pointer.drag_in_prog) return;
+    if(proc->types.pointer.scroll_obj) return;
     if(proc->types.pointer.gesture_sent) return;
 
     lv_obj_t * gesture_obj = proc->types.pointer.act_obj;
diff --git a/src/lv_core/lv_indev.h b/src/lv_core/lv_indev.h
index 403081f22..ebaf519c0 100644
--- a/src/lv_core/lv_indev.h
+++ b/src/lv_core/lv_indev.h
@@ -120,36 +120,28 @@ lv_gesture_dir_t lv_indev_get_gesture_dir(const lv_indev_t * indev);
 uint32_t lv_indev_get_key(const lv_indev_t * indev);
 
 /**
- * Check if there is dragging with an input device or not (for LV_INDEV_TYPE_POINTER and
+ * Check the current scroll direction of an input device (for LV_INDEV_TYPE_POINTER and
  * LV_INDEV_TYPE_BUTTON)
  * @param indev pointer to an input device
- * @return true: drag is in progress
+ * @return LV_SCROLL_DIR_NONE: no scrolling now
+ *         LV_SCROLL_DIR_HOR/VER
  */
-bool lv_indev_is_dragging(const lv_indev_t * indev);
+lv_scroll_dir_t lv_indev_get_scroll_dir(const lv_indev_t * indev);
 
 /**
- * Get the vector of dragging of an input device (for LV_INDEV_TYPE_POINTER and
+ * Get the movement vector 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
+ * @param point pointer to a point to store the types.pointer.vector
  */
 void lv_indev_get_vect(const lv_indev_t * indev, lv_point_t * point);
 
-/**
- * Manually finish dragging.
- * `LV_SIGNAL_DRAG_END` and `LV_EVENT_DRAG_END` will be sent.
- * @param indev pointer to an input device
- * @return `LV_RES_INV` if the object being dragged was deleted. Else `LV_RES_OK`.
- */
-lv_res_t lv_indev_finish_drag(lv_indev_t * indev);
-
 /**
  * Do nothing until the next release
  * @param indev pointer to an input device
  */
 void lv_indev_wait_release(lv_indev_t * indev);
 
-
 /**
  * Gets a pointer to the currently active object in indev proc functions.
  * NULL if no object is currently being handled or if groups aren't used.
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 5b1c9c068..053775ca9 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -329,10 +329,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     /*Set attributes*/
     new_obj->adv_hittest  = 0;
     new_obj->click        = 1;
-    new_obj->drag         = 0;
-    new_obj->drag_throw   = 0;
-    new_obj->drag_parent  = 0;
-    new_obj->drag_dir     = LV_DRAG_DIR_BOTH;
+    new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
     new_obj->hidden       = 0;
     new_obj->top          = 0;
     new_obj->protect      = LV_PROTECT_NONE;
@@ -340,6 +337,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->gesture_parent = parent ? 1 : 0;
     new_obj->focus_parent  = 0;
     new_obj->state = LV_STATE_DEFAULT;
+    new_obj->scroll.x = 0;
+    new_obj->scroll.y = 0;
 
     new_obj->ext_attr = NULL;
 
@@ -384,10 +383,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         /*Copy attributes*/
         new_obj->adv_hittest  = copy->adv_hittest;
         new_obj->click        = copy->click;
-        new_obj->drag         = copy->drag;
-        new_obj->drag_dir     = copy->drag_dir;
-        new_obj->drag_throw   = copy->drag_throw;
-        new_obj->drag_parent  = copy->drag_parent;
+        new_obj->scroll_mode  = copy->scroll_mode;
         new_obj->hidden       = copy->hidden;
         new_obj->top          = copy->top;
         new_obj->parent_event = copy->parent_event;
@@ -1613,55 +1609,17 @@ void lv_obj_set_top(lv_obj_t * obj, bool en)
 }
 
 /**
- * Enable the dragging of an object
+ * Set how the scrollbars should behave.
  * @param obj pointer to an object
- * @param en true: make the object draggable
+ * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
  */
-void lv_obj_set_drag(lv_obj_t * obj, bool en)
+void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(en == true) lv_obj_set_click(obj, true); /*Drag is useless without enabled clicking*/
-    obj->drag = (en == true ? 1 : 0);
-}
-
-/**
- * Set the directions an object can be dragged in
- * @param obj pointer to an object
- * @param drag_dir bitwise OR of allowed directions an object can be dragged in
- */
-void lv_obj_set_drag_dir(lv_obj_t * obj, lv_drag_dir_t drag_dir)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->drag_dir = drag_dir;
-
-    if(obj->drag_dir != 0) lv_obj_set_drag(obj, true); /*Drag direction requires drag*/
-}
-
-/**
- * Enable the throwing of an object after is is dragged
- * @param obj pointer to an object
- * @param en true: enable the drag throw
- */
-void lv_obj_set_drag_throw(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->drag_throw = (en == true ? 1 : 0);
-}
-
-/**
- * Enable to use parent for drag related operations.
- * If trying to drag the object the parent will be moved instead
- * @param obj pointer to an object
- * @param en true: enable the 'drag parent' for the object
- */
-void lv_obj_set_drag_parent(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->drag_parent = (en == true ? 1 : 0);
+    if(obj->scroll_mode == mode) return;
+    obj->scroll_mode = mode;
+    lv_obj_invalidate(obj);
 }
 
 /**
@@ -2944,61 +2902,15 @@ bool lv_obj_get_top(const lv_obj_t * obj)
 }
 
 /**
- * Get the drag enable attribute of an object
+ * Get how the scrollbars should behave.
  * @param obj pointer to an object
- * @return true: the object is draggable
+ * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
  */
-bool lv_obj_get_drag(const lv_obj_t * obj)
+lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return obj->drag == 0 ? false : true;
-}
-
-/**
- * Get the directions an object can be dragged
- * @param obj pointer to an object
- * @return bitwise OR of allowed directions an object can be dragged in
- */
-lv_drag_dir_t lv_obj_get_drag_dir(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->drag_dir;
-}
-
-/**
- * Get the directions an object can be scrolled
- * @param obj pointer to an object
- * @return bitwise OR of allowed directions an object can be dragged in
- */
-lv_drag_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->scroll_dir;
-}
-
-/**
- * Get the drag throw enable attribute of an object
- * @param obj pointer to an object
- * @return true: drag throw is enabled
- */
-bool lv_obj_get_drag_throw(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->drag_throw == 0 ? false : true;
-}
-
-/**
- * Get the drag parent attribute of an object
- * @param obj pointer to an object
- * @return true: drag parent is enabled
- */
-bool lv_obj_get_drag_parent(const lv_obj_t * obj)
-{
-    return obj->drag_parent == 0 ? false : true;
+    return obj->scroll_mode;
 }
 
 /**
@@ -3022,9 +2934,9 @@ bool lv_obj_get_focus_parent(const lv_obj_t * obj)
 }
 
 /**
- * Get the drag parent attribute of an object
+ * Get the parent event attribute of an object
  * @param obj pointer to an object
- * @return true: drag parent is enabled
+ * @return true: parent event is enabled
  */
 bool lv_obj_get_parent_event(const lv_obj_t * obj)
 {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index f2e01a33f..87286ec6a 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -85,15 +85,16 @@ enum {
     LV_EVENT_PRESSED,             /**< The object has been pressed*/
     LV_EVENT_PRESSING,            /**< The object is being pressed (called continuously while pressing)*/
     LV_EVENT_PRESS_LOST,          /**< User is still pressing but slid cursor/finger off of the object */
-    LV_EVENT_SHORT_CLICKED,       /**< User pressed object for a short period of time, then released it. Not called if dragged. */
-    LV_EVENT_LONG_PRESSED,        /**< Object has been pressed for at least `LV_INDEV_LONG_PRESS_TIME`.  Not called if dragged.*/
+    LV_EVENT_SHORT_CLICKED,       /**< User pressed object for a short period of time, then released it. Not called if scrolled. */
+    LV_EVENT_LONG_PRESSED,        /**< Object has been pressed for at least `LV_INDEV_LONG_PRESS_TIME`.  Not called if scrolled.*/
     LV_EVENT_LONG_PRESSED_REPEAT, /**< Called after `LV_INDEV_LONG_PRESS_TIME` in every
-                                       `LV_INDEV_LONG_PRESS_REP_TIME` ms.  Not called if dragged.*/
-    LV_EVENT_CLICKED,             /**< Called on release if not dragged (regardless to long press)*/
+                                       `LV_INDEV_LONG_PRESS_REP_TIME` ms.  Not called if scrolled.*/
+    LV_EVENT_CLICKED,             /**< Called on release if not scrolled (regardless to long press)*/
     LV_EVENT_RELEASED,            /**< Called in every cases when the object has been released*/
-    LV_EVENT_DRAG_BEGIN,
-    LV_EVENT_DRAG_END,
-    LV_EVENT_DRAG_THROW_BEGIN,
+    LV_EVENT_SCROLL_BEGIN,
+    LV_EVENT_SCROLL_THROW_BEGIN,
+    LV_EVENT_SCROLL_END,
+    LV_EVENT_SCROLL,
     LV_EVENT_GESTURE,           /**< The object has been gesture*/
     LV_EVENT_KEY,
     LV_EVENT_FOCUSED,
@@ -136,15 +137,13 @@ enum {
     LV_SIGNAL_PRESSED,           /**< The object has been pressed*/
     LV_SIGNAL_PRESSING,          /**< The object is being pressed (called continuously while pressing)*/
     LV_SIGNAL_PRESS_LOST,        /**< User is still pressing but slid cursor/finger off of the object */
-    LV_SIGNAL_RELEASED,          /**< User pressed object for a short period of time, then released it. Not called if dragged. */
-    LV_SIGNAL_LONG_PRESS,        /**< Object has been pressed for at least `LV_INDEV_LONG_PRESS_TIME`.  Not called if dragged.*/
-    LV_SIGNAL_LONG_PRESS_REP,    /**< Called after `LV_INDEV_LONG_PRESS_TIME` in every `LV_INDEV_LONG_PRESS_REP_TIME` ms.  Not called if dragged.*/
+    LV_SIGNAL_RELEASED,          /**< User pressed object for a short period of time, then released it. Not called if scrolled. */
+    LV_SIGNAL_LONG_PRESS,        /**< Object has been pressed for at least `LV_INDEV_LONG_PRESS_TIME`.  Not called if scrolled.*/
+    LV_SIGNAL_LONG_PRESS_REP,    /**< Called after `LV_INDEV_LONG_PRESS_TIME` in every `LV_INDEV_LONG_PRESS_REP_TIME` ms.  Not called if scrolled.*/
     LV_SIGNAL_SCROLL_BEGIN,      /**< The scrolling has just begun  */
     LV_SIGNAL_SCROLL,            /**< The object has been scrolled */
     LV_SIGNAL_SCROLL_END,        /**< The scrolling has ended */
-    LV_SIGNAL_DRAG_BEGIN,
-    LV_SIGNAL_DRAG_THROW_BEGIN,
-    LV_SIGNAL_DRAG_END,
+    LV_SIGNAL_SCROLL_THROW_BEGIN,/**< Scroll throw started*/
     LV_SIGNAL_GESTURE,          /**< The object has been gesture*/
     LV_SIGNAL_LEAVE,            /**< Another object is clicked or chosen via an input device */
 
@@ -196,6 +195,15 @@ enum {
 
 typedef uint8_t lv_state_t;
 
+/** Scrollbar modes: shows when should the scrollbars be visible*/
+enum {
+    LV_SCROLL_MODE_OFF    = 0x0, /**< Never show scroll bars*/
+    LV_SCROLL_MODE_ON     = 0x1, /**< Always show scroll bars*/
+    LV_SCROLL_MODE_ACTIVE = 0x2, /**< Show scroll bars when object is being scrolled*/
+    LV_SCROLL_MODE_AUTO   = 0x3, /**< Show scroll bars when the content is large enough to be scrolled*/
+};
+typedef uint8_t lv_scroll_mode_t;
+
 typedef struct _lv_obj_t {
     struct _lv_obj_t * parent; /**< Pointer to the parent object*/
     lv_ll_t child_ll;       /**< Linked list to store the children objects*/
@@ -221,19 +229,13 @@ typedef struct _lv_obj_t {
 
     /*Attributes and states*/
     uint8_t click           : 1; /**< 1: Can be pressed by an input device*/
-    uint8_t drag            : 1; /**< 1: Enable the dragging*/
-    uint8_t drag_throw      : 1; /**< 1: Enable throwing with drag*/
-    uint8_t drag_parent     : 1; /**< 1: Parent will be dragged instead*/
     uint8_t hidden          : 1; /**< 1: Object is hidden*/
     uint8_t top             : 1; /**< 1: If the object or its children is clicked it goes to the foreground*/
     uint8_t parent_event    : 1; /**< 1: Send the object's events to the parent too. */
     uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
     uint8_t gesture_parent  : 1; /**< 1: Parent will be gesture instead*/
     uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
-    lv_drag_dir_t scroll_elastic  : 3; /**< In which directions the object can be scrolled */
-
-    lv_drag_dir_t drag_dir    : 3; /**< In which directions the object can be dragged */
-    lv_drag_dir_t scroll_dir  : 3; /**< In which directions the object can be scrolled */
+    lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
 
 #if LV_USE_GROUP != 0
@@ -781,35 +783,6 @@ void lv_obj_set_click(lv_obj_t * obj, bool en);
  */
 void lv_obj_set_top(lv_obj_t * obj, bool en);
 
-/**
- * Enable the dragging of an object
- * @param obj pointer to an object
- * @param en true: make the object draggable
- */
-void lv_obj_set_drag(lv_obj_t * obj, bool en);
-
-/**
- * Set the directions an object can be dragged in
- * @param obj pointer to an object
- * @param drag_dir bitwise OR of allowed drag directions
- */
-void lv_obj_set_drag_dir(lv_obj_t * obj, lv_drag_dir_t drag_dir);
-
-/**
- * Enable the throwing of an object after is is dragged
- * @param obj pointer to an object
- * @param en true: enable the drag throw
- */
-void lv_obj_set_drag_throw(lv_obj_t * obj, bool en);
-
-/**
- * Enable to use parent for drag related operations.
- * If trying to drag the object the parent will be moved instead
- * @param obj pointer to an object
- * @param en true: enable the 'drag parent' for the object
- */
-void lv_obj_set_drag_parent(lv_obj_t * obj, bool en);
-
 /**
 * Enable to use parent for focus state.
 * When object is focused the parent will get the state instead (visual only)
@@ -818,6 +791,13 @@ void lv_obj_set_drag_parent(lv_obj_t * obj, bool en);
 */
 void lv_obj_set_focus_parent(lv_obj_t * obj, bool en);
 
+/**
+ * Set how the scrollbars should behave.
+ * @param obj pointer to an object
+ * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode);
+
 /**
 * Enable to use parent for gesture related operations.
 * If trying to gesture the object the parent will be moved instead
@@ -1314,42 +1294,6 @@ bool lv_obj_get_click(const lv_obj_t * obj);
  */
 bool lv_obj_get_top(const lv_obj_t * obj);
 
-/**
- * Get the drag enable attribute of an object
- * @param obj pointer to an object
- * @return true: the object is draggable
- */
-bool lv_obj_get_drag(const lv_obj_t * obj);
-
-/**
- * Get the directions an object can be dragged
- * @param obj pointer to an object
- * @return bitwise OR of allowed directions an object can be dragged in
- */
-lv_drag_dir_t lv_obj_get_drag_dir(const lv_obj_t * obj);
-
-/**
- * Get the directions an object can be scrolled
- * @param obj pointer to an object
- * @return bitwise OR of allowed directions an object can be dragged in
- */
-lv_drag_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj);
-
-/**
- * Get the drag throw enable attribute of an object
- * @param obj pointer to an object
- * @return true: drag throw is enabled
- */
-bool lv_obj_get_drag_throw(const lv_obj_t * obj);
-
-/**
- * Get the drag parent attribute of an object
- * @param obj pointer to an object
- * @return true: drag parent is enabled
- */
-bool lv_obj_get_drag_parent(const lv_obj_t * obj);
-
-
 /**
 * Get the focus parent attribute of an object
 * @param obj pointer to an object
@@ -1357,11 +1301,10 @@ bool lv_obj_get_drag_parent(const lv_obj_t * obj);
 */
 bool lv_obj_get_focus_parent(const lv_obj_t * obj);
 
-
 /**
- * Get the drag parent attribute of an object
+ * Get the parent event attribute of an object
  * @param obj pointer to an object
- * @return true: drag parent is enabled
+ * @return true: parent event is enabled
  */
 bool lv_obj_get_parent_event(const lv_obj_t * obj);
 
diff --git a/src/lv_hal/lv_hal_indev.c b/src/lv_hal/lv_hal_indev.c
index ca4404816..c0f2f4835 100644
--- a/src/lv_hal/lv_hal_indev.c
+++ b/src/lv_hal/lv_hal_indev.c
@@ -54,8 +54,8 @@ void lv_indev_drv_init(lv_indev_drv_t * driver)
     _lv_memset_00(driver, sizeof(lv_indev_drv_t));
 
     driver->type                 = LV_INDEV_TYPE_NONE;
-    driver->drag_limit           = LV_INDEV_DEF_DRAG_LIMIT;
-    driver->drag_throw           = LV_INDEV_DEF_DRAG_THROW;
+    driver->scroll_limit           = LV_INDEV_DEF_DRAG_LIMIT;
+    driver->scroll_throw           = LV_INDEV_DEF_DRAG_THROW;
     driver->long_press_time      = LV_INDEV_DEF_LONG_PRESS_TIME;
     driver->long_press_rep_time  = LV_INDEV_DEF_LONG_PRESS_REP_TIME;
     driver->gesture_limit        = LV_INDEV_DEF_GESTURE_LIMIT;
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index a4af05936..b49080db3 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -52,14 +52,12 @@ typedef uint8_t lv_indev_state_t;
 
 
 enum {
-    LV_DRAG_DIR_NONE = 0x0, /**< Object can't be dragged to any directions. */
-    LV_DRAG_DIR_HOR = 0x1, /**< Object can be dragged horizontally. */
-    LV_DRAG_DIR_VER = 0x2, /**< Object can be dragged vertically. */
-    LV_DRAG_DIR_BOTH = 0x3, /**< Object can be dragged in all directions. */
-    LV_DRAG_DIR_ONE = 0x4, /**< Object can be dragged only one direction (the first move). */
+    LV_SCROLL_DIR_NONE = 0x0, /**< Object can't be dragged to any directions. */
+    LV_SCROLL_DIR_HOR = 0x1, /**< Object can be dragged horizontally. */
+    LV_SCROLL_DIR_VER = 0x2, /**< Object can be dragged vertically. */
 };
 
-typedef uint8_t lv_drag_dir_t;
+typedef uint8_t lv_scroll_dir_t;
 
 enum {
     LV_GESTURE_DIR_TOP,     /**< Gesture dir up. */
@@ -106,10 +104,10 @@ typedef struct _lv_indev_drv_t {
     lv_task_t * read_task;
 
     /**< Number of pixels to slide before actually drag the object*/
-    uint8_t drag_limit;
+    uint8_t scroll_limit;
 
     /**< Drag throw slow-down in [%]. Greater value means faster slow-down */
-    uint8_t drag_throw;
+    uint8_t scroll_throw;
 
     /**< At least this difference should between two points to evaluate as gesture */
     uint8_t gesture_min_velocity;
@@ -135,20 +133,18 @@ typedef struct _lv_indev_proc_t {
             lv_point_t act_point; /**< Current point of input device. */
             lv_point_t last_point; /**< Last point of input device. */
             lv_point_t vect; /**< Difference between `act_point` and `last_point`. */
-            lv_point_t drag_sum; /*Count the dragged pixels to check LV_INDEV_DEF_DRAG_LIMIT*/
-            lv_point_t drag_throw_vect;
+            lv_point_t scroll_sum; /*Count the dragged pixels to check LV_INDEV_DEF_DRAG_LIMIT*/
+            lv_point_t scroll_throw_vect;
             struct _lv_obj_t * act_obj;      /*The object being pressed*/
             struct _lv_obj_t * last_obj;     /*The last object which was pressed (used by drag_throw and
                                                 other post-release event)*/
-            struct _lv_obj_t * drag_obj;      /*The object being pressed*/
+            struct _lv_obj_t * scroll_obj;      /*The object being scrolled*/
             struct _lv_obj_t * last_pressed; /*The lastly pressed object*/
 
             lv_gesture_dir_t gesture_dir;
             lv_point_t gesture_sum; /*Count the gesture pixels to check LV_INDEV_DEF_GESTURE_LIMIT*/
             /*Flags*/
-            uint8_t drag_limit_out : 1;
-            uint8_t drag_in_prog : 1;
-            lv_drag_dir_t drag_dir  : 3;
+            lv_scroll_dir_t scroll_dir  : 2;
             uint8_t gesture_sent : 1;
         } pointer;
         struct {
diff --git a/src/lv_widgets/lv_btn.c b/src/lv_widgets/lv_btn.c
index fa327bd6e..e3d7d9325 100644
--- a/src/lv_widgets/lv_btn.c
+++ b/src/lv_widgets/lv_btn.c
@@ -273,7 +273,7 @@ static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
     if(sign == LV_SIGNAL_RELEASED) {
         /*If not dragged and it was not long press action then
          *change state and run the action*/
-        if(lv_indev_is_dragging(param) == false && tgl) {
+        if(lv_indev_get_scroll_dir(param) == LV_SCROLL_DIR_NONE && tgl) {
             uint32_t toggled = 0;
             if(lv_obj_get_state(btn, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
                 lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
diff --git a/src/lv_widgets/lv_cpicker.c b/src/lv_widgets/lv_cpicker.c
index d80c9a56c..21d1c09c2 100644
--- a/src/lv_widgets/lv_cpicker.c
+++ b/src/lv_widgets/lv_cpicker.c
@@ -768,8 +768,8 @@ static lv_res_t lv_cpicker_signal(lv_obj_t * cpicker, lv_signal_t sign, void * p
             lv_indev_get_point(indev, &p);
         }
 
-        if((LV_MATH_ABS(p.x - ext->last_press_point.x) > indev->driver.drag_limit / 2) ||
-           (LV_MATH_ABS(p.y - ext->last_press_point.y) > indev->driver.drag_limit / 2)) {
+        if((LV_MATH_ABS(p.x - ext->last_press_point.x) > indev->driver.scroll_limit / 2) ||
+           (LV_MATH_ABS(p.y - ext->last_press_point.y) > indev->driver.scroll_limit / 2)) {
             ext->last_change_time = lv_tick_get();
             ext->last_press_point.x = p.x;
             ext->last_press_point.y = p.y;
diff --git a/src/lv_widgets/lv_dropdown.c b/src/lv_widgets/lv_dropdown.c
index c7bbd8746..e6b05eba8 100644
--- a/src/lv_widgets/lv_dropdown.c
+++ b/src/lv_widgets/lv_dropdown.c
@@ -930,7 +930,7 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
     }
     else if(sign == LV_SIGNAL_RELEASED) {
         lv_indev_t * indev = lv_indev_get_act();
-        if(lv_indev_is_dragging(indev) == false) {
+        if(lv_indev_is_scrolling(indev) == false) {
             if(ext->page) {
                 lv_dropdown_close(ddlist);
                 if(ext->sel_opt_id_orig != ext->sel_opt_id) {
@@ -1034,7 +1034,7 @@ static lv_res_t lv_dropdown_page_signal(lv_obj_t * page, lv_signal_t sign, void
         scrl->ext_draw_pad = LV_MATH_MAX3(scrl->ext_draw_pad, left, right);
     }
     else if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_dragging(lv_indev_get_act()) == false) {
+        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
             page_release_handler(page);
         }
     }
@@ -1071,7 +1071,7 @@ static lv_res_t lv_dropdown_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign,
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_dragging(lv_indev_get_act()) == false) {
+        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
             page_release_handler(page);
         }
     }
diff --git a/src/lv_widgets/lv_list.c b/src/lv_widgets/lv_list.c
index 76ba666ff..d1d370a87 100644
--- a/src/lv_widgets/lv_list.c
+++ b/src/lv_widgets/lv_list.c
@@ -688,7 +688,7 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
                         res = lv_event_send(ext->act_sel_btn, LV_EVENT_SHORT_CLICKED, NULL);
                         if(res != LV_RES_OK) return res;
                     }
-                    if(lv_indev_is_dragging(indev) == false) {
+                    if(lv_indev_is_scrolling(indev) == false) {
                         res = lv_event_send(ext->act_sel_btn, LV_EVENT_CLICKED, NULL);
                         if(res != LV_RES_OK) return res;
                     }
@@ -806,7 +806,7 @@ static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * para
         }
     }
     else if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_dragging(lv_indev_get_act()) == false) {
+        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
             lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));
             lv_list_focus_btn(list, btn);
 #if LV_USE_GROUP
diff --git a/src/lv_widgets/lv_page.c b/src/lv_widgets/lv_page.c
index 89c6c0f0e..f7e1a8e34 100644
--- a/src/lv_widgets/lv_page.c
+++ b/src/lv_widgets/lv_page.c
@@ -932,7 +932,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
             if(parent_ext->scroll_prop_obj == NULL) {
                 /*If the dragging just started or scroll is already propagated to this object
                  *  enable the scroll propagation if the conditions are met*/
-                if((lv_indev_is_dragging(indev) == false || page_ext->scroll_prop_obj) && (drag_sum->y || drag_sum->x)) {
+                if((lv_indev_is_scrolling(indev) == false || page_ext->scroll_prop_obj) && (drag_sum->y || drag_sum->x)) {
                     /*Propagate vertically?*/
                     if((drag_sum->y > 0 && lv_page_on_edge(page, LV_PAGE_EDGE_TOP)) ||
                        (drag_sum->y < 0 && lv_page_on_edge(page, LV_PAGE_EDGE_BOTTOM))) {
diff --git a/src/lv_widgets/lv_roller.c b/src/lv_widgets/lv_roller.c
index 46f81221a..9b1672ceb 100644
--- a/src/lv_widgets/lv_roller.c
+++ b/src/lv_widgets/lv_roller.c
@@ -885,7 +885,7 @@ static lv_res_t release_handler(lv_obj_t * roller)
 {
 
     /*If there was dragging `DRAG_END` signal will refresh the position and update the selected option*/
-    if(lv_indev_is_dragging(lv_indev_get_act())) return LV_RES_OK;
+    if(lv_indev_is_scrolling(lv_indev_get_act())) return LV_RES_OK;
 
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
 
diff --git a/src/lv_widgets/lv_tileview.c b/src/lv_widgets/lv_tileview.c
index 0ea0f8133..f5dae125c 100644
--- a/src/lv_widgets/lv_tileview.c
+++ b/src/lv_widgets/lv_tileview.c
@@ -380,7 +380,7 @@ static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void
             }
 
             /*Apply the drag constraints*/
-            lv_drag_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
+            lv_scroll_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
             if(drag_dir == LV_DRAG_DIR_HOR)
                 lv_obj_set_y(scrl, -ext->act_id.y * lv_obj_get_height(tileview) + top);
             else if(drag_dir == LV_DRAG_DIR_VER)
@@ -406,7 +406,7 @@ static void drag_end_handler(lv_obj_t * tileview)
     p.x = -(lv_obj_get_x(scrl) - lv_obj_get_width(tileview) / 2);
     p.y = -(lv_obj_get_y(scrl) - lv_obj_get_height(tileview) / 2);
 
-    lv_drag_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
+    lv_scroll_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
     /*From the drag vector (drag throw) predict the end position*/
     if(drag_dir & LV_DRAG_DIR_HOR) {
         lv_point_t vect;

From 7a1d9e77538a8d3253143fe0fbbcdf5bc7b15a44 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 21 Jul 2020 21:47:31 +0200
Subject: [PATCH 11/84] scroll: handle scroll modes

---
 src/lv_core/lv_indev.c   |  12 +++
 src/lv_core/lv_indev.h   |   8 ++
 src/lv_core/lv_obj.c     | 160 +++++++++++++++++++++++----------------
 src/lv_hal/lv_hal_disp.c |   3 +
 4 files changed, 117 insertions(+), 66 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 2be5474d9..4159326fd 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -299,6 +299,18 @@ lv_scroll_dir_t lv_indev_get_scroll_dir(const lv_indev_t * indev)
     if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) return false;
     return indev->proc.types.pointer.scroll_dir;
 }
+/**
+ * Get the currently scrolled object (for LV_INDEV_TYPE_POINTER and
+ * LV_INDEV_TYPE_BUTTON)
+ * @param indev pointer to an input device
+ * @return pointer to the currently scrolled object or NULL if no scrolling by this indev
+ */
+lv_obj_t * lv_indev_get_scroll_obj(const lv_indev_t * indev)
+{
+    if(indev == NULL) return NULL;
+    if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) return NULL;
+    return indev->proc.types.pointer.scroll_obj;
+}
 
 /**
  * Get the movement vector of an input device (for LV_INDEV_TYPE_POINTER and
diff --git a/src/lv_core/lv_indev.h b/src/lv_core/lv_indev.h
index ebaf519c0..2b6c69161 100644
--- a/src/lv_core/lv_indev.h
+++ b/src/lv_core/lv_indev.h
@@ -128,6 +128,14 @@ uint32_t lv_indev_get_key(const lv_indev_t * indev);
  */
 lv_scroll_dir_t lv_indev_get_scroll_dir(const lv_indev_t * indev);
 
+/**
+ * Get the currently scrolled object (for LV_INDEV_TYPE_POINTER and
+ * LV_INDEV_TYPE_BUTTON)
+ * @param indev pointer to an input device
+ * @return pointer to the currently scrolled object or NULL if no scrolling by this indev
+ */
+lv_obj_t * lv_indev_get_scroll_obj(const lv_indev_t * indev);
+
 /**
  * Get the movement vector of an input device (for LV_INDEV_TYPE_POINTER and
  * LV_INDEV_TYPE_BUTTON)
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 053775ca9..3f23fbd96 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -106,7 +106,7 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
 static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
-static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor, const lv_area_t * clip_area);
+static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area);
 
 /**********************
  *  STATIC VARIABLES
@@ -3800,18 +3800,8 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
 
-        if(lv_obj_get_screen(obj) == lv_scr_act()) {
-            lv_draw_rect_dsc_t sb_rect_dsc;
-            lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &sb_rect_dsc);
-            if(sb_res == LV_RES_OK) {
-                lv_area_t hor_area;
-                lv_area_t ver_area;
-                scrollbar_get_area(obj, &hor_area, &ver_area, clip_area);
 
-                lv_draw_rect(&hor_area, clip_area, &sb_rect_dsc);
-                lv_draw_rect(&ver_area, clip_area, &sb_rect_dsc);
-            }
-        }
+        scrollbar_draw(obj, clip_area);
 
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
             lv_draw_mask_radius_param_t * param = lv_draw_mask_remove_custom(obj + 8);
@@ -3887,9 +3877,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     }
     else if(sign == LV_SIGNAL_SCROLL_END) {
 
-//        lv_area_t child_box;
-//        lv_obj_get_children_box(obj, &child_box);
-
         lv_coord_t st = lv_obj_get_scroll_top(obj);
         lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
         lv_coord_t sl = lv_obj_get_scroll_left(obj);
@@ -3912,6 +3899,11 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
                 lv_obj_scroll_by(obj, -sr, 0, LV_ANIM_ON);
             }
         }
+
+        if(lv_obj_get_scroll_mode(obj) == LV_SCROLL_MODE_ACTIVE) {
+            lv_obj_invalidate(obj);
+        }
+
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         lv_coord_t d = lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
@@ -4521,8 +4513,39 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
     }
 }
 
-static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor, const lv_area_t * clip_area)
+static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
 {
+    lv_scroll_dir_t sm = lv_obj_get_scroll_mode(obj);
+    if(sm == LV_SCROLL_MODE_OFF) {
+        return;
+    }
+
+    lv_coord_t st = lv_obj_get_scroll_top(obj);
+    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
+    lv_coord_t sl = lv_obj_get_scroll_left(obj);
+    lv_coord_t sr = lv_obj_get_scroll_right(obj);
+
+    /*Return if too small content to scroll*/
+    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sl <= 0) {
+        return;
+    }
+
+    /*If there is no indev scrolling this object but the moe is active return*/
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    if(sm == LV_SCROLL_MODE_ACTIVE) {
+        bool found = false;
+        while(indev) {
+            if(lv_indev_get_scroll_obj(indev) == obj) {
+                found = true;
+                break;
+            }
+            indev = lv_indev_get_next(indev);
+        }
+        if(!found) {
+            return;
+        }
+    }
+
     lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
     lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
     lv_coord_t tickness = lv_obj_get_style_scrollbar_tickness(obj, LV_OBJ_PART_MAIN);
@@ -4530,88 +4553,93 @@ static void scrollbar_get_area(lv_obj_t * obj, lv_area_t * ver, lv_area_t * hor,
     lv_coord_t obj_h = lv_obj_get_height(obj);
     lv_coord_t obj_w = lv_obj_get_width(obj);
 
-    lv_coord_t st = lv_obj_get_scroll_top(obj);
-    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
-    lv_coord_t sl = lv_obj_get_scroll_left(obj);
-    lv_coord_t sr = lv_obj_get_scroll_right(obj);
-
     lv_coord_t ver_reg_space = tickness + side_space;
     lv_coord_t hor_req_space = tickness + side_space;
     lv_coord_t rem;
 
-    ver->y1 = obj->coords.y1;
-    ver->y2 = obj->coords.y2;
-    ver->x2 = obj->coords.x2;
-    ver->x1 = ver->x2 - tickness;
+    lv_draw_rect_dsc_t draw_dsc;
+    lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
+    if(sb_res != LV_RES_OK) return;
 
-    if(_lv_area_is_on(ver, clip_area)) {
+    lv_area_t area;
+    area.y1 = obj->coords.y1;
+    area.y2 = obj->coords.y2;
+    area.x2 = obj->coords.x2;
+    area.x1 = area.x2 - tickness;
+
+    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
+    if(_lv_area_is_on(&area, clip_area) &&
+        ((sm == LV_SCROLL_MODE_ON) ||
+         (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
+         (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER))) {
         lv_coord_t content_h = obj_h + st + sb;
         lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
         sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
         rem = (obj_h - end_space * 2 - hor_req_space) - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
         lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
         if(scroll_h <= 0) {
-            ver->y1 = obj->coords.y1 + end_space;
-            ver->y2 = obj->coords.y2 - end_space - hor_req_space - 1;
-            ver->x2 = obj->coords.x2;
-            ver->x1 = ver->x2 - tickness + 1;
+            area.y1 = obj->coords.y1 + end_space;
+            area.y2 = obj->coords.y2 - end_space - hor_req_space - 1;
+            area.x2 = obj->coords.x2;
+            area.x1 = area.x2 - tickness + 1;
         } else {
             lv_coord_t sb_y = (rem * sb) / scroll_h;
             sb_y = rem - sb_y;
 
-            ver->y1 = obj->coords.y1 + sb_y + end_space;
-            ver->y2 = ver->y1 + sb_h - 1;
-            ver->x2 = obj->coords.x2;
-            ver->x1 = ver->x2 - tickness;
-            if(ver->y1 < obj->coords.y1) {
-                ver->y1 = obj->coords.y1;
-                if(ver->y1 + SCROLLBAR_MIN_SIZE > ver->y2) ver->y2 = ver->y1 + SCROLLBAR_MIN_SIZE;
+            area.y1 = obj->coords.y1 + sb_y + end_space;
+            area.y2 = area.y1 + sb_h - 1;
+            area.x2 = obj->coords.x2;
+            area.x1 = area.x2 - tickness;
+            if(area.y1 < obj->coords.y1) {
+                area.y1 = obj->coords.y1;
+                if(area.y1 + SCROLLBAR_MIN_SIZE > area.y2) area.y2 = area.y1 + SCROLLBAR_MIN_SIZE;
             }
-            if(ver->y2 > obj->coords.y2) {
-                ver->y2 = obj->coords.y2;
-                if(ver->y2 - SCROLLBAR_MIN_SIZE < ver->y1) ver->y1 = ver->y2 - SCROLLBAR_MIN_SIZE;
+            if(area.y2 > obj->coords.y2) {
+                area.y2 = obj->coords.y2;
+                if(area.y2 - SCROLLBAR_MIN_SIZE < area.y1) area.y1 = area.y2 - SCROLLBAR_MIN_SIZE;
             }
         }
-    } else {
-        /*Set an invalid area if not in the clip area*/
-        lv_area_set(ver, -1, -1, -2, -2);
+        lv_draw_rect(&area, clip_area, &draw_dsc);
+
     }
 
-    hor->y2 = obj->coords.y2;
-    hor->y1 = hor->y2 - tickness;
-    hor->x1 = obj->coords.x1;
-    hor->x2 = obj->coords.x2;
-    if(_lv_area_is_on(hor, clip_area)) {
-        lv_coord_t content_w = obj_w + sl + sr;
+    area.y2 = obj->coords.y2;
+    area.y1 =area.y2 - tickness;
+    area.x1 = obj->coords.x1;
+    area.x2 = obj->coords.x2;
+    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
+    if(_lv_area_is_on(&area, clip_area) &&
+        ((sm == LV_SCROLL_MODE_ON) ||
+         (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
+         (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR))) {
+       lv_coord_t content_w = obj_w + sl + sr;
         lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
         sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
         rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
         lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
         if(scroll_w <= 0) {
-            hor->y2 = obj->coords.y2;
-            hor->y1 = hor->y2 - tickness + 1;
-            hor->x1 = obj->coords.x1 + end_space;
-            hor->x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
+            area.y2 = obj->coords.y2;
+            area.y1 = area.y2 - tickness + 1;
+            area.x1 = obj->coords.x1 + end_space;
+            area.x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
         } else {
             lv_coord_t sb_x = (rem * sr) / scroll_w;
             sb_x = rem - sb_x;
 
-            hor->x1 = obj->coords.x1 + sb_x + end_space;
-            hor->x2 = hor->x1 + sb_w - 1;
-            hor->y2 = obj->coords.y2;
-            hor->y1 = hor->y2 - tickness;
-            if(hor->x1 < obj->coords.x1) {
-                hor->x1 = obj->coords.x1;
-                if(hor->x1 + SCROLLBAR_MIN_SIZE > hor->x2) hor->x2 = hor->x1 + SCROLLBAR_MIN_SIZE;
+            area.x1 = obj->coords.x1 + sb_x + end_space;
+            area.x2 = area.x1 + sb_w - 1;
+            area.y2 = obj->coords.y2;
+            area.y1 = area.y2 - tickness;
+            if(area.x1 < obj->coords.x1) {
+                area.x1 = obj->coords.x1;
+                if(area.x1 + SCROLLBAR_MIN_SIZE > area.x2) area.x2 = area.x1 + SCROLLBAR_MIN_SIZE;
             }
-            if(hor->x2 > obj->coords.x2) {
-                hor->x2 = obj->coords.x2;
-                if(hor->x2 - SCROLLBAR_MIN_SIZE < hor->x1) hor->x1 = hor->x2 - SCROLLBAR_MIN_SIZE;
+            if(area.x2 > obj->coords.x2) {
+                area.x2 = obj->coords.x2;
+                if(area.x2 - SCROLLBAR_MIN_SIZE < area.x1) area.x1 = area.x2 - SCROLLBAR_MIN_SIZE;
             }
         }
-    } else {
-        /*Set an invalid area if not in the clip area*/
-        lv_area_set(hor, -1, -1, -2, -2);
+        lv_draw_rect(&area, clip_area, &draw_dsc);
     }
 }
 
diff --git a/src/lv_hal/lv_hal_disp.c b/src/lv_hal/lv_hal_disp.c
index d87afb55f..ed5fbc90c 100644
--- a/src/lv_hal/lv_hal_disp.c
+++ b/src/lv_hal/lv_hal_disp.c
@@ -161,6 +161,9 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
     lv_obj_set_click(disp->top_layer, false);
     lv_obj_set_click(disp->sys_layer, false);
 
+    lv_obj_set_scroll_mode(disp->top_layer, LV_SCROLL_MODE_OFF);
+    lv_obj_set_scroll_mode(disp->sys_layer, LV_SCROLL_MODE_OFF);
+
     lv_obj_invalidate(disp->act_scr);
 
     disp_def = disp_def_tmp; /*Revert the default display*/

From 0b78cbf937853246371f93416bedd5704d232a61 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 21 Jul 2020 22:12:04 +0200
Subject: [PATCH 12/84] scroll: minor fixes

---
 src/lv_core/lv_obj.c | 59 +++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 26 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 3f23fbd96..59c151e58 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -4553,8 +4553,22 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t obj_h = lv_obj_get_height(obj);
     lv_coord_t obj_w = lv_obj_get_width(obj);
 
-    lv_coord_t ver_reg_space = tickness + side_space;
-    lv_coord_t hor_req_space = tickness + side_space;
+    bool ver_draw = false;
+    if((sm == LV_SCROLL_MODE_ON) ||
+       (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
+       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER)) {
+        ver_draw = true;
+    }
+
+    bool hor_draw = false;
+    if((sm == LV_SCROLL_MODE_ON) ||
+       (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
+       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR)) {
+        hor_draw = true;
+    }
+
+    lv_coord_t ver_reg_space = ver_draw ? tickness + side_space : 0;
+    lv_coord_t hor_req_space = hor_draw ? tickness + side_space : 0;
     lv_coord_t rem;
 
     lv_draw_rect_dsc_t draw_dsc;
@@ -4564,14 +4578,11 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_area_t area;
     area.y1 = obj->coords.y1;
     area.y2 = obj->coords.y2;
-    area.x2 = obj->coords.x2;
+    area.x2 = obj->coords.x2 - side_space;
     area.x1 = area.x2 - tickness;
 
     /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
-    if(_lv_area_is_on(&area, clip_area) &&
-        ((sm == LV_SCROLL_MODE_ON) ||
-         (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
-         (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER))) {
+    if(ver_draw && _lv_area_is_on(&area, clip_area)) {
         lv_coord_t content_h = obj_h + st + sb;
         lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
         sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
@@ -4580,7 +4591,7 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
         if(scroll_h <= 0) {
             area.y1 = obj->coords.y1 + end_space;
             area.y2 = obj->coords.y2 - end_space - hor_req_space - 1;
-            area.x2 = obj->coords.x2;
+            area.x2 = obj->coords.x2 - side_space;
             area.x1 = area.x2 - tickness + 1;
         } else {
             lv_coord_t sb_y = (rem * sb) / scroll_h;
@@ -4588,37 +4599,33 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
 
             area.y1 = obj->coords.y1 + sb_y + end_space;
             area.y2 = area.y1 + sb_h - 1;
-            area.x2 = obj->coords.x2;
+            area.x2 = obj->coords.x2 - side_space;
             area.x1 = area.x2 - tickness;
-            if(area.y1 < obj->coords.y1) {
-                area.y1 = obj->coords.y1;
+            if(area.y1 < obj->coords.y1 + end_space) {
+                area.y1 = obj->coords.y1 + end_space;
                 if(area.y1 + SCROLLBAR_MIN_SIZE > area.y2) area.y2 = area.y1 + SCROLLBAR_MIN_SIZE;
             }
-            if(area.y2 > obj->coords.y2) {
-                area.y2 = obj->coords.y2;
+            if(area.y2 > obj->coords.y2 - hor_req_space - end_space) {
+                area.y2 = obj->coords.y2 - hor_req_space - end_space;
                 if(area.y2 - SCROLLBAR_MIN_SIZE < area.y1) area.y1 = area.y2 - SCROLLBAR_MIN_SIZE;
             }
         }
         lv_draw_rect(&area, clip_area, &draw_dsc);
-
     }
 
-    area.y2 = obj->coords.y2;
+    area.y2 = obj->coords.y2 - side_space;
     area.y1 =area.y2 - tickness;
     area.x1 = obj->coords.x1;
     area.x2 = obj->coords.x2;
     /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
-    if(_lv_area_is_on(&area, clip_area) &&
-        ((sm == LV_SCROLL_MODE_ON) ||
-         (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
-         (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR))) {
-       lv_coord_t content_w = obj_w + sl + sr;
+    if(hor_draw && _lv_area_is_on(&area, clip_area)) {
+        lv_coord_t content_w = obj_w + sl + sr;
         lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
         sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
         rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
         lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
         if(scroll_w <= 0) {
-            area.y2 = obj->coords.y2;
+            area.y2 = obj->coords.y2 - side_space;
             area.y1 = area.y2 - tickness + 1;
             area.x1 = obj->coords.x1 + end_space;
             area.x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
@@ -4628,14 +4635,14 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
 
             area.x1 = obj->coords.x1 + sb_x + end_space;
             area.x2 = area.x1 + sb_w - 1;
-            area.y2 = obj->coords.y2;
+            area.y2 = obj->coords.y2 - side_space;
             area.y1 = area.y2 - tickness;
-            if(area.x1 < obj->coords.x1) {
-                area.x1 = obj->coords.x1;
+            if(area.x1 < obj->coords.x1 + end_space) {
+                area.x1 = obj->coords.x1 + end_space;
                 if(area.x1 + SCROLLBAR_MIN_SIZE > area.x2) area.x2 = area.x1 + SCROLLBAR_MIN_SIZE;
             }
-            if(area.x2 > obj->coords.x2) {
-                area.x2 = obj->coords.x2;
+            if(area.x2 > obj->coords.x2 - ver_reg_space - end_space) {
+                area.x2 = obj->coords.x2 - ver_reg_space - end_space;
                 if(area.x2 - SCROLLBAR_MIN_SIZE < area.x1) area.x1 = area.x2 - SCROLLBAR_MIN_SIZE;
             }
         }

From 2278fb36104f45f2103fe3f7f5b4c0fb2ee9bd44 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 21 Jul 2020 22:12:13 +0200
Subject: [PATCH 13/84] add styling to material theme

---
 src/lv_themes/lv_theme_material.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 1aa9fe580..01e79bf8b 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -221,6 +221,14 @@ static void basic_init(void)
     lv_style_set_image_recolor(&styles->bg, LV_STATE_DEFAULT, COLOR_BG_TEXT);
     lv_style_set_line_color(&styles->bg, LV_STATE_DEFAULT, COLOR_BG_TEXT);
     lv_style_set_line_width(&styles->bg, LV_STATE_DEFAULT, 1);
+
+    lv_style_set_scrollbar_bg_opa(&styles->bg, LV_STATE_DEFAULT, LV_OPA_COVER);
+    lv_style_set_scrollbar_bg_color(&styles->bg, LV_STATE_DEFAULT, (IS_LIGHT ? lv_color_hex(0xcccfd1) : lv_color_hex(0x777f85)));
+    lv_style_set_scrollbar_radius(&styles->bg, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+    lv_style_set_scrollbar_tickness(&styles->bg, LV_STATE_DEFAULT, LV_DPX(7));
+    lv_style_set_scrollbar_space_side(&styles->bg, LV_STATE_DEFAULT,  LV_DPX(7));
+    lv_style_set_scrollbar_space_end(&styles->bg, LV_STATE_DEFAULT,  LV_DPX(7));
+
     lv_style_set_pad_left(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_right(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_top(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);

From f739506dddf4d96a6f96c86e4448ea353eecac49 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 5 Aug 2020 11:06:48 +0200
Subject: [PATCH 14/84] add linemeter's mirror feature again the drawing part
 was somehow removed

---
 CHANGELOG.md                  |  1 +
 src/lv_widgets/lv_linemeter.c | 12 ++++++------
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b0748227c..62fc6fec0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 ### Bugfixes
 - Fix drawing value string twice
 - Rename  `lv_chart_clear_serie` to `lv_chart_clear_series` and `lv_obj_align_origo` to `lv_obj_align_mid`
+- Add linemeter's mirror feature again
 
 ## v7.3.0 (04.08.2020)
 
diff --git a/src/lv_widgets/lv_linemeter.c b/src/lv_widgets/lv_linemeter.c
index c8e7ae724..d8043f876 100644
--- a/src/lv_widgets/lv_linemeter.c
+++ b/src/lv_widgets/lv_linemeter.c
@@ -392,15 +392,15 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
     lv_coord_t x_ofs  = lmeter->coords.x1 + r_out + left;
     lv_coord_t y_ofs  = lmeter->coords.y1 + r_out + top;
     int16_t angle_ofs = ext->angle_ofs + 90 + (360 - ext->scale_angle) / 2;
-    int16_t level =
-        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
+    int16_t level = ext->mirrored ?
+            (int32_t)((int32_t)(ext->max_value - ext->cur_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value) :
+            (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
     uint8_t i;
 
     lv_color_t main_color = lv_obj_get_style_line_color(lmeter, part);
     lv_color_t grad_color = lv_obj_get_style_scale_grad_color(lmeter, part);
     lv_color_t end_color = lv_obj_get_style_scale_end_color(lmeter, part);
 
-
     lv_draw_line_dsc_t line_dsc;
     lv_draw_line_dsc_init(&line_dsc);
     lv_obj_init_draw_line_dsc(lmeter, part, &line_dsc);
@@ -520,11 +520,11 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
         p1.y = y_out_extra;
 
         /* Set the color of the lines */
-        if(i > level) {
+        uint16_t index = ext->mirrored ? ext->line_cnt - i : i;
+        if((!ext->mirrored && i >= level) || (ext->mirrored && i <= level)) {
             line_dsc.color = end_color;
             line_dsc.width = end_line_width;
-        }
-        else {
+        } else {
             line_dsc.color = lv_color_mix(grad_color, main_color, (255 * i) / ext->line_cnt);
         }
 

From 756522a64c3efc2be4e344512afbec1965bc8db9 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 19 Aug 2020 20:16:20 +0200
Subject: [PATCH 15/84] add auto size

---
 src/lv_api_map.h       |  15 ---
 src/lv_core/lv_indev.c |   4 +-
 src/lv_core/lv_obj.c   | 300 ++++++++++-------------------------------
 src/lv_core/lv_obj.h   |  88 +-----------
 src/lv_misc/lv_area.h  |   7 +
 5 files changed, 84 insertions(+), 330 deletions(-)

diff --git a/src/lv_api_map.h b/src/lv_api_map.h
index d8e904e8a..578fabe6b 100644
--- a/src/lv_api_map.h
+++ b/src/lv_api_map.h
@@ -209,21 +209,6 @@ static inline void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * se
 
 #endif
 
-static inline void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs)
-{
-    lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
-}
-
-static inline void lv_obj_align_origo_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
-{
-    lv_obj_align_mid_y(obj, base, align, x_ofs);
-}
-
-static inline void lv_obj_align_origo_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
-{
-    lv_obj_align_mid_y(obj, base, align, y_ofs);
-}
-
 #endif /*LV_USE_API_EXTENSION_V6*/
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index af756f4b5..e820fe127 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1292,7 +1292,7 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
             if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
             if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
         }
-        lv_obj_scroll_by(scroll_obj, diff_x, diff_y, LV_ANIM_OFF);
+        lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
     }
 }
 
@@ -1335,7 +1335,7 @@ static void indev_scroll_throw_handler(lv_indev_proc_t * proc)
     }
 
     if((proc->types.pointer.scroll_throw_vect.x != 0 || proc->types.pointer.scroll_throw_vect.y != 0)) {
-        lv_obj_scroll_by(scroll_obj, proc->types.pointer.scroll_throw_vect.x, proc->types.pointer.scroll_throw_vect.y, LV_ANIM_OFF);
+        lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, proc->types.pointer.scroll_throw_vect.y);
     }
     /*If the vectors become 0 then finish scrolling
        signal*/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 0436c8cb3..f5b818d7a 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -307,15 +307,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->ext_click_pad_ver = 0;
 #endif
 
-    /*Init realign*/
-#if LV_USE_OBJ_REALIGN
-    new_obj->realign.align        = LV_ALIGN_CENTER;
-    new_obj->realign.xofs         = 0;
-    new_obj->realign.yofs         = 0;
-    new_obj->realign.base         = NULL;
-    new_obj->realign.auto_realign = 0;
-#endif
-
     /*Init. user date*/
 #if LV_USE_USER_DATA
     _lv_memset_00(&new_obj->user_data, sizeof(lv_obj_user_data_t));
@@ -368,15 +359,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         _lv_memcpy(&new_obj->user_data, &copy->user_data, sizeof(lv_obj_user_data_t));
 #endif
 
-        /*Copy realign*/
-#if LV_USE_OBJ_REALIGN
-        new_obj->realign.align        = copy->realign.align;
-        new_obj->realign.xofs         = copy->realign.xofs;
-        new_obj->realign.yofs         = copy->realign.yofs;
-        new_obj->realign.base         = copy->realign.base;
-        new_obj->realign.auto_realign = copy->realign.auto_realign;
-#endif
-
         /*Only copy the `event_cb`. `signal_cb` and `design_cb` will be copied in the derived
          * object type (e.g. `lv_btn`)*/
         new_obj->event_cb = copy->event_cb;
@@ -678,24 +660,20 @@ void lv_obj_move_background(lv_obj_t * obj)
  * Coordinate set
  * ------------------*/
 
-/**
- * Set relative the position of an object (relative to the parent)
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+static void refr_pos(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
     /*Convert x and y to absolute coordinates*/
     lv_obj_t * par = obj->parent;
 
+    lv_coord_t x = obj->x_set;
+    lv_coord_t y = obj->y_set;
     if(par) {
-        x = x + par->coords.x1;
-        y = y + par->coords.y1;
-    }
+        lv_coord_t pad_left = lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
+        lv_coord_t pad_top = lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
 
+        x += pad_left + par->coords.x1 - lv_obj_get_scroll_left(par);
+        y += pad_top + par->coords.y1 - lv_obj_get_scroll_top(par);
+    }
 
     /*Calculate and set the movement*/
     lv_point_t diff;
@@ -731,6 +709,23 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     lv_obj_invalidate(obj);
 }
 
+/**
+ * Set relative the position of an object (relative to the parent)
+ * @param obj pointer to an object
+ * @param x new distance from the left side of the parent
+ * @param y new distance from the top of the parent
+ */
+void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->x_set = x;
+    obj->y_set = y;
+
+    refr_pos(obj);
+
+}
+
 /**
  * Set the x coordinate of a object
  * @param obj pointer to an object
@@ -755,15 +750,27 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
     lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
 }
 
-/**
- * Set the size of an object
- * @param obj pointer to an object
- * @param w new width
- * @param h new height
- */
-void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
+static void refr_size(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+    lv_coord_t w = 0;
+    lv_coord_t h = 0;
+
+
+    if(LV_COORD_IS_AUTO(obj->w_set)) {
+        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
+        w = lv_obj_get_width(obj) + scroll_right;
+    } else {
+        w = obj->w_set;
+    }
+
+    if(LV_COORD_IS_AUTO(obj->h_set)) {
+        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
+        h = lv_obj_get_height(obj) + scroll_bottom;
+    } else {
+        h = obj->h_set;
+    }
 
     /* Do nothing if the size is not changed */
     /* It is very important else recursive resizing can
@@ -803,11 +810,22 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
+}
 
-    /*Automatically realign the object if required*/
-#if LV_USE_OBJ_REALIGN
-    if(obj->realign.auto_realign) lv_obj_realign(obj);
-#endif
+/**
+ * Set the size of an object
+ * @param obj pointer to an object
+ * @param w new width
+ * @param h new height
+ */
+void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->w_set = w;
+    obj->h_set = h;
+
+    refr_size(obj);
 }
 
 /**
@@ -905,163 +923,6 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
     LV_ASSERT_OBJ(base, LV_OBJX_NAME);
 
     obj_align_core(obj, base, align, true, true, x_ofs, y_ofs);
-
-#if LV_USE_OBJ_REALIGN
-    /*Save the last align parameters to use them in `lv_obj_realign`*/
-    obj->realign.align       = align;
-    obj->realign.xofs        = x_ofs;
-    obj->realign.yofs        = y_ofs;
-    obj->realign.base        = base;
-    obj->realign.mid_align = 0;
-#endif
-}
-
-/**
- * Align an object to an other object horizontally.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- */
-void lv_obj_align_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) base = lv_obj_get_parent(obj);
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-    obj_align_core(obj, base, align, true, false, x_ofs, 0);
-}
-
-/**
- * Align an object to an other object vertically.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) base = lv_obj_get_parent(obj);
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-    obj_align_core(obj, base, align, true, false, 0, y_ofs);
-}
-
-/**
- * Align an object's middle point to an other object.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_mid(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) {
-        base = lv_obj_get_parent(obj);
-    }
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-
-    obj_align_mid_core(obj, base, align, true, true, x_ofs, y_ofs);
-
-#if LV_USE_OBJ_REALIGN
-    /*Save the last align parameters to use them in `lv_obj_realign`*/
-    obj->realign.align       = align;
-    obj->realign.xofs        = x_ofs;
-    obj->realign.yofs        = y_ofs;
-    obj->realign.base        = base;
-    obj->realign.mid_align = 1;
-#endif
-}
-
-/**
- * Align an object's middle point to an other object horizontally.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- */
-void lv_obj_align_mid_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) {
-        base = lv_obj_get_parent(obj);
-    }
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-
-    obj_align_mid_core(obj, base, align, true, false, x_ofs, 0);
-}
-
-
-/**
- * Align an object's middle point to an other object vertically.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_mid_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) {
-        base = lv_obj_get_parent(obj);
-    }
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-
-    obj_align_mid_core(obj, base, align, true, false, 0, y_ofs);
-}
-
-/**
- * Realign the object based on the last `lv_obj_align` parameters.
- * @param obj pointer to an object
- */
-void lv_obj_realign(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-#if LV_USE_OBJ_REALIGN
-    if(obj->realign.mid_align)
-        lv_obj_align_mid(obj, obj->realign.base, obj->realign.align, obj->realign.xofs, obj->realign.yofs);
-    else
-        lv_obj_align(obj, obj->realign.base, obj->realign.align, obj->realign.xofs, obj->realign.yofs);
-#else
-    (void)obj;
-    LV_LOG_WARN("lv_obj_realign: no effect because LV_USE_OBJ_REALIGN = 0");
-#endif
-}
-
-/**
- * Enable the automatic realign of the object when its size has changed based on the last
- * `lv_obj_align` parameters.
- * @param obj pointer to an object
- * @param en true: enable auto realign; false: disable auto realign
- */
-void lv_obj_set_auto_realign(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-#if LV_USE_OBJ_REALIGN
-    obj->realign.auto_realign = en ? 1 : 0;
-#else
-    (void)obj;
-    (void)en;
-    LV_LOG_WARN("lv_obj_set_auto_realign: no effect because LV_USE_OBJ_REALIGN = 0");
-#endif
 }
 
 /**
@@ -1103,7 +964,7 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
         lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
 
         if(x) {
-            lv_anim_set_time(&a, lv_anim_speed_to_time(lv_disp_get_hor_res(d), 0, x));
+            lv_anim_set_time(&a, lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 3) >> 2, 0, x));
             lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
             lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
             lv_anim_set_path(&a, &path);
@@ -1140,7 +1001,7 @@ void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  */
 void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, x - obj->scroll.x, 0, anim_en);
+    lv_obj_scroll_by(obj, -x - obj->scroll.x, 0, anim_en);
 }
 
 /**
@@ -1150,7 +1011,7 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
  */
 void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, 0, y - obj->scroll.y, anim_en);
+    lv_obj_scroll_by(obj, 0,  -y - obj->scroll.y, anim_en);
 }
 
 
@@ -2302,7 +2163,9 @@ lv_coord_t lv_obj_get_x(const lv_obj_t * obj)
     lv_coord_t rel_x;
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent) {
-        rel_x             = obj->coords.x1 - parent->coords.x1;
+        rel_x   = obj->coords.x1 - parent->coords.x1;
+        rel_x += lv_obj_get_scroll_left(parent);
+        rel_x -= lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
     }
     else {
         rel_x = obj->coords.x1;
@@ -2322,7 +2185,9 @@ lv_coord_t lv_obj_get_y(const lv_obj_t * obj)
     lv_coord_t rel_y;
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent) {
-        rel_y             = obj->coords.y1 - parent->coords.y1;
+        rel_y = obj->coords.y1 - parent->coords.y1;
+        rel_y += lv_obj_get_scroll_top(parent);
+        rel_y -= lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
     }
     else {
         rel_y = obj->coords.y1;
@@ -2454,23 +2319,6 @@ lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span)
     return r;
 }
 
-/**
- * Get the automatic realign property of the object.
- * @param obj pointer to an object
- * @return  true: auto realign is enabled; false: auto realign is disabled
- */
-bool lv_obj_get_auto_realign(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-#if LV_USE_OBJ_REALIGN
-    return obj->realign.auto_realign ? true : false;
-#else
-    (void)obj;
-    return false;
-#endif
-}
-
 /**
  * Get the left padding of extended clickable area
  * @param obj pointer to an object
@@ -3898,13 +3746,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         lv_coord_t d = lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
-#if LV_USE_OBJ_REALIGN
-    else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
-        if(obj->realign.auto_realign) {
-            lv_obj_realign(obj);
-        }
-    }
-#endif
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         lv_obj_refresh_ext_draw_pad(obj);
     }
@@ -4000,6 +3841,7 @@ static void report_style_mod_core(void * style, lv_obj_t * obj)
 
 }
 
+
 /**
  * Recursively refresh the style of the children. Go deeper until a not NULL style is found
  * because the NULL styles are inherited from the parent
@@ -4512,7 +4354,7 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t sr = lv_obj_get_scroll_right(obj);
 
     /*Return if too small content to scroll*/
-    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sl <= 0) {
+    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sr <= 0) {
         return;
     }
 
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index ff8e36aa3..22d9339af 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -157,18 +157,6 @@ typedef uint8_t lv_signal_t;
 
 typedef lv_res_t (*lv_signal_cb_t)(struct _lv_obj_t * obj, lv_signal_t sign, void * param);
 
-#if LV_USE_OBJ_REALIGN
-typedef struct {
-    const struct _lv_obj_t * base;
-    lv_coord_t xofs;
-    lv_coord_t yofs;
-    lv_align_t align;
-    uint8_t auto_realign : 1;
-    uint8_t mid_align : 1; /**< 1: the origo (center of the object) was aligned with
-                                `lv_obj_align_origo`*/
-} lv_realign_t;
-#endif
-
 /*Protect some attributes (max. 8 bit)*/
 enum {
     LV_PROTECT_NONE      = 0x00,
@@ -237,6 +225,10 @@ typedef struct _lv_obj_t {
     uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
+    lv_coord_t x_set;
+    lv_coord_t y_set;
+    lv_coord_t w_set;
+    lv_coord_t h_set;
 
 #if LV_USE_GROUP != 0
     void * group_p;
@@ -246,10 +238,6 @@ typedef struct _lv_obj_t {
                                      'OR'ed values from `lv_protect_t`*/
     lv_state_t state;
 
-#if LV_USE_OBJ_REALIGN
-    lv_realign_t realign;       /**< Information about the last call to ::lv_obj_align. */
-#endif
-
 #if LV_USE_USER_DATA
     lv_obj_user_data_t user_data; /**< Custom user data for object. */
 #endif
@@ -476,67 +464,6 @@ void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
  */
 void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
 
-/**
- * Align an object to an other object horizontally.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- */
-void lv_obj_align_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs);
-
-/**
- * Align an object to an other object vertically.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs);
-
-/**
- * Align an object to an other object.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_mid(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
-
-
-/**
- * Align an object's middle point to an other object horizontally.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- */
-void lv_obj_align_mid_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs);
-
-/**
- * Align an object's middle point to an other object vertically.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align_mid_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs);
-
-/**
- * Realign the object based on the last `lv_obj_align` parameters.
- * @param obj pointer to an object
- */
-void lv_obj_realign(lv_obj_t * obj);
-
-/**
- * Enable the automatic realign of the object when its size has changed based on the last
- * `lv_obj_align` parameters.
- * @param obj pointer to an object
- * @param en true: enable auto realign; false: disable auto realign
- */
-void lv_obj_set_auto_realign(lv_obj_t * obj, bool en);
-
 /**
  * Moves all children with horizontally or vertically.
  * It doesn't take into account any limits so any values are possible
@@ -1123,13 +1050,6 @@ lv_coord_t lv_obj_get_width_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
  */
 lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
 
-/**
- * Get the automatic realign property of the object.
- * @param obj pointer to an object
- * @return  true: auto realign is enabled; false: auto realign is disabled
- */
-bool lv_obj_get_auto_realign(const lv_obj_t * obj);
-
 /**
  * Get the left padding of extended clickable area
  * @param obj pointer to an object
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index 879a9c03a..6bbb3afb2 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -208,6 +208,13 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
  *      MACROS
  **********************/
 
+#define LV_COORD_PX(x)  (x)
+#define LV_COORD_AUTO (LV_COORD_MAX - 100)
+
+#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX - 1000) ? true : false)
+#define LV_COORD_IS_AUTO(x) (((x) == LV_COORD_MAX - 100) ? true : false)
+
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

From 43b706f2d420f2d6dd1bd0dc74a4e7d19b7ded9d Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 26 Aug 2020 15:25:35 +0200
Subject: [PATCH 16/84] add layout files

---
 src/lv_core/lv_layout.c | 0
 src/lv_core/lv_layout.h | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 src/lv_core/lv_layout.c
 create mode 100644 src/lv_core/lv_layout.h

diff --git a/src/lv_core/lv_layout.c b/src/lv_core/lv_layout.c
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/lv_core/lv_layout.h b/src/lv_core/lv_layout.h
new file mode 100644
index 000000000..e69de29bb

From 5d345c1d562d7d26fd6398bad05ecb753855e8d6 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 27 Aug 2020 09:39:27 +0200
Subject: [PATCH 17/84] start grid

---
 src/lv_core/lv_align.c  | 36 +++++++++++++++++++++++++++
 src/lv_core/lv_align.h  | 54 +++++++++++++++++++++++++++++++++++++++++
 src/lv_core/lv_layout.c |  0
 src/lv_core/lv_layout.h |  0
 src/lv_core/lv_obj.c    | 11 +++------
 5 files changed, 93 insertions(+), 8 deletions(-)
 create mode 100644 src/lv_core/lv_align.c
 create mode 100644 src/lv_core/lv_align.h
 delete mode 100644 src/lv_core/lv_layout.c
 delete mode 100644 src/lv_core/lv_layout.h

diff --git a/src/lv_core/lv_align.c b/src/lv_core/lv_align.c
new file mode 100644
index 000000000..580c08a5c
--- /dev/null
+++ b/src/lv_core/lv_align.c
@@ -0,0 +1,36 @@
+/**
+ * @file lv_align.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
diff --git a/src/lv_core/lv_align.h b/src/lv_core/lv_align.h
new file mode 100644
index 000000000..74f0af775
--- /dev/null
+++ b/src/lv_core/lv_align.h
@@ -0,0 +1,54 @@
+/**
+ * @file lv_templ.h
+ *
+ */
+
+#ifndef LV_ALIGN_H
+#define LV_ALIGN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    const lv_coord_t * col_dsc;
+    const lv_coord_t * row_dsc;
+    lv_coord_t gap_col;
+    lv_coord_t gap_row;
+    uint8_t flow;
+    uint8_t place_content;
+    uint8_t place_items;
+}lv_grid_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_grid_init(lv_grid_t * grid);
+
+void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv_coord_t * row_dsc);
+
+void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_mode, uint8_t row_mode);
+
+void lv_grid_set_place_items(lv_grid_t * grid, uint8_t col_mode, uint8_t row_mode);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_ALIGN_H*/
diff --git a/src/lv_core/lv_layout.c b/src/lv_core/lv_layout.c
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/lv_core/lv_layout.h b/src/lv_core/lv_layout.h
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 021357ae4..b04278d01 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -106,15 +106,12 @@ static void lv_event_mark_deleted(lv_obj_t * obj);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
-<<<<<<< HEAD
 static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
 static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area);
-
-=======
 static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop);
 static void update_style_cache_children(lv_obj_t * obj);
 static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
->>>>>>> master
+
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -4484,7 +4481,7 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
     return false;
 }
 
-<<<<<<< HEAD
+
 static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
 {
     lv_draw_rect_dsc_init(dsc);
@@ -4648,7 +4645,7 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
     }
 }
 
-=======
+
 static bool style_prop_is_cacheble(lv_style_property_t prop)
 {
 
@@ -4846,5 +4843,3 @@ static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_proper
         child = lv_obj_get_child(obj, child);
     }
 }
->>>>>>> master
-

From c801a2cfa2449792f380d72f2136cdbe35216fbb Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 28 Aug 2020 18:48:52 +0200
Subject: [PATCH 18/84] basic grid working

---
 src/lv_core/lv_align.c |  50 +++++++++
 src/lv_core/lv_align.h |  90 ++++++++++++++--
 src/lv_core/lv_obj.c   | 240 +++++++++++++++++++++++++++++------------
 src/lv_core/lv_obj.h   |   3 +
 src/lv_misc/lv_area.h  |  11 +-
 5 files changed, 316 insertions(+), 78 deletions(-)

diff --git a/src/lv_core/lv_align.c b/src/lv_core/lv_align.c
index 580c08a5c..a9ed4cf83 100644
--- a/src/lv_core/lv_align.c
+++ b/src/lv_core/lv_align.c
@@ -6,6 +6,7 @@
 /*********************
  *      INCLUDES
  *********************/
+#include "lv_align.h"
 
 /*********************
  *      DEFINES
@@ -31,6 +32,55 @@
  *   GLOBAL FUNCTIONS
  **********************/
 
+void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc)
+{
+    calc->col_dsc_len = grid->col_dsc_len + 1;
+    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
+    calc->row_dsc_len = grid->row_dsc_len + 1;
+    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+
+    calc->col_dsc[0] = 0;
+    calc->row_dsc[0] = 0;
+
+    uint8_t i;
+    for(i = 0; i < grid->col_dsc_len; i++) {
+        calc->col_dsc[i + 1] = calc->col_dsc[i] + grid->col_dsc[i];
+    }
+    for(i = 0; i < grid->row_dsc_len; i++) {
+        calc->row_dsc[i + 1] = calc->row_dsc[i] + grid->row_dsc[i];
+    }
+}
+
+void grid_calc_free(_lv_grid_calc_t * calc)
+{
+    _lv_mem_buf_release(calc->col_dsc);
+    _lv_mem_buf_release(calc->row_dsc);
+}
+
+uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t col)
+{
+    lv_coord_t x;
+    /*If explicitly defined get the column size else use the first column*/
+    if(col < grid->col_dsc_len) x = grid->col_dsc[col];
+    else x = grid->col_dsc[0];
+
+    if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
+    else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
+    else return _GRID_CELL_SIZE_PX;
+}
+
+uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t row)
+{
+    lv_coord_t x;
+    /*If explicitly defined get the row size else use the first row*/
+    if(row < grid->row_dsc_len) x = grid->row_dsc[row];
+    else x = grid->row_dsc[0];
+
+    if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
+    else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
+    else return _GRID_CELL_SIZE_PX;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_align.h b/src/lv_core/lv_align.h
index 74f0af775..c32e422a6 100644
--- a/src/lv_core/lv_align.h
+++ b/src/lv_core/lv_align.h
@@ -1,5 +1,5 @@
 /**
- * @file lv_templ.h
+ * @file lv_grid.h
  *
  */
 
@@ -13,24 +13,94 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
+#include "../lv_misc/lv_area.h"
 
 /*********************
  *      DEFINES
  *********************/
 
+#define LV_GRID_CENTER              0
+#define LV_GRID_START               1
+#define LV_GRID_END                 2
+#define LV_GRID_STRETCH             3
+#define LV_GRID_SPACE_EVENLY        4
+#define LV_GRID_SPACE_AROUND        5
+#define LV_GRID_SPACE_BETWEEN       6
+
+/**
+ * Some helper defines
+ * */
+#define _GRID_IS_CELL(c)        ((c) > LV_COORD_MAX ? true : false)
+#define _GRID_CELL_SHIFT        5
+#define _GRID_CELL_MAX          ((1 << _GRID_CELL_SHIFT) - 1)
+#define _GRID_CELL_POS_MASK     ((1 << _GRID_CELL_SHIFT) - 1)
+#define _GRID_CELL_SPAN_MASK    (_GRID_CELL_POS_MASK << _GRID_CELL_SHIFT)
+#define _GRID_CELL_FLAG_MASK    (_GRID_CELL_POS_MASK << (2 * _GRID_CELL_SHIFT))
+#define _GRID_CELL_FLAG(b)      ((b) << (_GRID_CELL_SHIFT * 2))
+#define _GRID_CELL_AUTO         _GRID_CELL_MAX
+#define _GRID_GET_CELL_POS(c)   ((c) & _GRID_CELL_POS_MASK)
+#define _GRID_GET_CELL_SPAN(c)  (((c) & _GRID_CELL_SPAN_MASK) >> _GRID_CELL_SHIFT)
+#define _GRID_GET_CELL_FLAG(c)  ((c) >> (_GRID_CELL_SHIFT * 2) & 0x3)
+
+#define _GRID_CELL_SIZE_PX    0     /* The cell size is set in pixels*/
+#define _GRID_CELL_SIZE_FR    1     /* The cell size is set in free units*/
+#define _GRID_CELL_SIZE_AUTO  2     /* The cell size is automatically set to content*/
+
+#define LV_GRID_FR(x)   (LV_COORD_MAX + (x))
+#define LV_GRID_AUTO    LV_COORD_AUTO
+
+#define _GRID_IS_PX(x) ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
+#define _GRID_IS_FR(x) (x > LV_COORD_MAX ? true : false)
+#define _GRID_IS_AUTO(x) (x == LV_GRID_AUTO ? true : false)
+
+
+/**
+ * Define a grid cell with position and span.
+ * Can be used like `lv_obj_set_pos(btn, LV_GRID_CELL(3,2), LV_GRID_CELL(2,1))`
+ */
+#define LV_GRID_CELL_START(pos, span)   ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_START))
+#define LV_GRID_CELL_END(pos, span)     ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_END))
+#define LV_GRID_CELL_CENTER(pos, span)  ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_CENTER))
+#define LV_GRID_CELL_STRETCH(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_STRETCH))
+
+/**
+ * Special LV_GRID_CELL position to flow the object automatically.
+ * Both X (column) and Y (row) value needs to be AUTO or explicitly specified*/
+#define LV_GRID_AUTO_START      LV_GRID_CELL_START(_GRID_CELL_AUTO, 0)
+#define LV_GRID_AUTO_END        LV_GRID_CELL_END(_GRID_CELL_AUTO, 0)
+#define LV_GRID_AUTO_CENTER     LV_GRID_CELL_CENTER(_GRID_CELL_AUTO, 0)
+#define LV_GRID_AUTO_STRETCH    LV_GRID_CELL_STRETCH(_GRID_CELL_AUTO, 0)
+
 /**********************
  *      TYPEDEFS
  **********************/
+
+/**
+ * Describe how to flow LV_GRID_POS_AUTO elements
+ */
+typedef enum {
+    LV_GRID_FLOW_COLUMN, /**Fill each column and add now columns if required*/
+    LV_GRID_FLOW_ROW,    /**Fill each row and add now rows if required*/
+}lv_grid_flow_t;
+
 typedef struct {
     const lv_coord_t * col_dsc;
     const lv_coord_t * row_dsc;
-    lv_coord_t gap_col;
-    lv_coord_t gap_row;
-    uint8_t flow;
+    uint8_t col_dsc_len;
+    uint8_t row_dsc_len;
+    lv_coord_t col_gap;
+    lv_coord_t row_gap;
+    lv_grid_flow_t flow;
     uint8_t place_content;
-    uint8_t place_items;
 }lv_grid_t;
 
+typedef struct {
+    lv_coord_t * col_dsc;
+    lv_coord_t * row_dsc;
+    uint8_t col_dsc_len;
+    uint8_t row_dsc_len;
+}_lv_grid_calc_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -39,9 +109,15 @@ void lv_grid_init(lv_grid_t * grid);
 
 void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv_coord_t * row_dsc);
 
-void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_mode, uint8_t row_mode);
+void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
 
-void lv_grid_set_place_items(lv_grid_t * grid, uint8_t col_mode, uint8_t row_mode);
+void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc);
+
+void grid_calc_free(_lv_grid_calc_t * calc);
+
+uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t row);
+
+uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t col);
 
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index b04278d01..7f19e3865 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -699,19 +699,25 @@ void lv_obj_move_background(lv_obj_t * obj)
  * Coordinate set
  * ------------------*/
 
-static void refr_pos(lv_obj_t * obj)
+static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 {
     /*Convert x and y to absolute coordinates*/
     lv_obj_t * par = obj->parent;
 
-    lv_coord_t x = obj->x_set;
-    lv_coord_t y = obj->y_set;
     if(par) {
         lv_coord_t pad_left = lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
         lv_coord_t pad_top = lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
 
         x += pad_left + par->coords.x1 - lv_obj_get_scroll_left(par);
         y += pad_top + par->coords.y1 - lv_obj_get_scroll_top(par);
+    } else {
+        /*If no parent then it's screen but screen can't be on a grid*/
+        if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
+            obj->x_set = 0;
+            obj->y_set = 0;
+            x = 0;
+            y = 0;
+        }
     }
 
     /*Calculate and set the movement*/
@@ -748,76 +754,18 @@ static void refr_pos(lv_obj_t * obj)
     lv_obj_invalidate(obj);
 }
 
-/**
- * Set relative the position of an object (relative to the parent)
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+
+static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 {
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->x_set = x;
-    obj->y_set = y;
-
-    refr_pos(obj);
-
-}
-
-/**
- * Set the x coordinate of a object
- * @param obj pointer to an object
- * @param x new distance from the left side from the parent
- */
-void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
-}
-
-/**
- * Set the y coordinate of a object
- * @param obj pointer to an object
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
-}
-
-static void refr_size(lv_obj_t * obj)
-{
-    lv_coord_t w = 0;
-    lv_coord_t h = 0;
-
-
-    if(LV_COORD_IS_AUTO(obj->w_set)) {
-        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
-        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
-        w = lv_obj_get_width(obj) + scroll_right;
-    } else {
-        w = obj->w_set;
-    }
-
-    if(LV_COORD_IS_AUTO(obj->h_set)) {
-        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
-        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
-        h = lv_obj_get_height(obj) + scroll_bottom;
-    } else {
-        h = obj->h_set;
-    }
 
     /* Do nothing if the size is not changed */
     /* It is very important else recursive resizing can
      * occur without size change*/
     if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
-        return;
+        return false;
     }
 
+
     /*Invalidate the original area*/
     lv_obj_invalidate(obj);
 
@@ -849,6 +797,121 @@ static void refr_size(lv_obj_t * obj)
 
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
+
+    return true;
+}
+
+
+
+static void lv_grid_refresh_item_pos(lv_obj_t * obj)
+{
+    /*Calculate the grid*/
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    lv_coord_t * col_dsc;
+    lv_coord_t * row_dsc;
+    uint8_t col_num;
+    uint8_t row_num;
+    _lv_grid_calc_t calc;
+    grid_calc(parent->grid, &calc);
+
+    uint8_t col_pos = _GRID_GET_CELL_POS(obj->x_set);
+    uint8_t col_span = _GRID_GET_CELL_SPAN(obj->x_set);
+    uint8_t row_pos = _GRID_GET_CELL_POS(obj->y_set);
+    uint8_t row_span = _GRID_GET_CELL_SPAN(obj->y_set);
+
+    lv_coord_t col_w = calc.col_dsc[col_pos + col_span] - calc.col_dsc[col_pos];
+    lv_coord_t row_h = calc.row_dsc[row_pos + row_span] - calc.row_dsc[row_pos];
+
+    uint8_t x_flag = _GRID_GET_CELL_FLAG(obj->x_set);
+    uint8_t y_flag = _GRID_GET_CELL_FLAG(obj->y_set);
+
+    lv_coord_t x;
+    lv_coord_t y;
+    lv_coord_t w = lv_obj_get_width(obj);
+    lv_coord_t h = lv_obj_get_height(obj);
+
+    switch(x_flag) {
+        case LV_GRID_START:
+            x = calc.col_dsc[col_pos];
+            break;
+        case LV_GRID_STRETCH:
+            x = calc.col_dsc[col_pos];
+            w = col_w;
+            break;
+        case LV_GRID_CENTER:
+            x = calc.col_dsc[col_pos] + (col_w - w) / 2;
+            break;
+        case LV_GRID_END:
+            x = calc.col_dsc[col_pos + 1] - lv_obj_get_width(obj);
+            break;
+    }
+
+    switch(y_flag) {
+        case LV_GRID_START:
+            y = calc.row_dsc[row_pos];
+            break;
+        case LV_GRID_STRETCH:
+            y = calc.row_dsc[row_pos];
+            h = row_h;
+            break;
+        case LV_GRID_CENTER:
+            y = calc.row_dsc[row_pos] + (row_h - h) / 2;
+            break;
+        case LV_GRID_END:
+            y = calc.row_dsc[row_pos + 1] - lv_obj_get_height(obj);
+            break;
+    }
+
+    refr_pos(obj, x, y);
+    refr_size(obj, w, h);
+
+    grid_calc_free(&calc);
+}
+
+
+/**
+ * Set relative the position of an object (relative to the parent)
+ * @param obj pointer to an object
+ * @param x new distance from the left side of the parent
+ * @param y new distance from the top of the parent
+ */
+void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->x_set = x;
+    obj->y_set = y;
+
+    /*If the object is on a grid item let grid to position it. */
+    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->x_set)) {
+        lv_grid_refresh_item_pos(obj);
+    } else {
+        refr_pos(obj, x, y);
+    }
+}
+
+/**
+ * Set the x coordinate of a object
+ * @param obj pointer to an object
+ * @param x new distance from the left side from the parent
+ */
+void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
+}
+
+/**
+ * Set the y coordinate of a object
+ * @param obj pointer to an object
+ * @param y new distance from the top of the parent
+ */
+void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
 }
 
 /**
@@ -864,7 +927,52 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     obj->w_set = w;
     obj->h_set = h;
 
-    refr_size(obj);
+    /*If the object is a grid element and stretched, prevent settings its size */
+    bool x_stretch = false;
+    bool y_stretch = false;
+    x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
+    y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
+
+    if(x_stretch && y_stretch) return;
+
+    lv_coord_t grid_w = 0;
+    lv_coord_t grid_h = 0;
+    if(((LV_COORD_IS_AUTO(obj->w_set) && !x_stretch) ||
+        (LV_COORD_IS_AUTO(obj->h_set) && !y_stretch))) {
+        _lv_grid_calc_t calc;
+        grid_calc(obj->grid, &calc);
+        grid_w = calc.col_dsc[calc.col_dsc_len - 1];
+        grid_h = calc.row_dsc[calc.row_dsc_len - 1];
+        grid_calc_free(&calc);
+    }
+
+
+    if(x_stretch) w = lv_obj_get_width(obj);
+    else {
+        if(LV_COORD_IS_AUTO(obj->w_set)) {
+            lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+            lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
+            w = lv_obj_get_width(obj) + scroll_right;
+            w = LV_MATH_MAX(w, grid_w);
+        }
+    }
+
+    if(y_stretch) h = lv_obj_get_height(obj);
+    else {
+        if(LV_COORD_IS_AUTO(obj->h_set) && !x_stretch) {
+            lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+            lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
+            h = lv_obj_get_height(obj) + scroll_bottom;
+            h = LV_MATH_MAX(h, grid_h);
+        }
+    }
+
+    bool chg = refr_size(obj, w, h);
+
+    /*Refresh the position in the grid item if required*/
+    if(chg && (_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->y_set))) {
+        lv_grid_refresh_item_pos(obj);
+    }
 }
 
 /**
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index e0188a0b5..9c0ee22fc 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -18,6 +18,7 @@ extern "C" {
 #include <stddef.h>
 #include <stdbool.h>
 #include "lv_style.h"
+#include "lv_align.h"
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_color.h"
@@ -243,6 +244,8 @@ typedef struct _lv_obj_t {
     lv_obj_user_data_t user_data; /**< Custom user data for object. */
 #endif
 
+    lv_grid_t * grid;
+
 } lv_obj_t;
 
 enum {
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index 6bbb3afb2..86ee4a186 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -22,8 +22,9 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
-/*To avoid overflow don't let the max ranges (reduce with 1000) */
-#define LV_COORD_MAX ((lv_coord_t)((uint32_t)((uint32_t)1 << (8 * sizeof(lv_coord_t) - 1)) - 1000))
+#define _LV_COORD_MAX_REDUCE    8192
+/*To allow some special values in the end reduce the max value */
+#define LV_COORD_MAX ((lv_coord_t)((uint32_t)((uint32_t)1 << (8 * sizeof(lv_coord_t) - 1)) - _LV_COORD_MAX_REDUCE))
 #define LV_COORD_MIN (-LV_COORD_MAX)
 
 LV_EXPORT_CONST_INT(LV_COORD_MAX);
@@ -209,10 +210,10 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
  **********************/
 
 #define LV_COORD_PX(x)  (x)
-#define LV_COORD_AUTO (LV_COORD_MAX - 100)
+#define LV_COORD_AUTO (LV_COORD_MAX - 1)
 
-#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX - 1000) ? true : false)
-#define LV_COORD_IS_AUTO(x) (((x) == LV_COORD_MAX - 100) ? true : false)
+#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX) ? true : false)
+#define LV_COORD_IS_AUTO(x) (((x) == LV_COORD_AUTO) ? true : false)
 
 
 #ifdef __cplusplus

From 03fa6b492c4c8aa9ef336bdfeffbd151fc7bd2d8 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sun, 30 Aug 2020 20:05:50 +0200
Subject: [PATCH 19/84] grid fuly works

---
 src/lv_api_map.h       |   6 +-
 src/lv_core/lv_align.c | 215 +++++++++++++++++++++----
 src/lv_core/lv_align.h |  17 +-
 src/lv_core/lv_obj.c   | 353 ++++++++++++++++++++++++++++++-----------
 src/lv_core/lv_obj.h   |   3 +
 src/lv_misc/lv_area.h  |   7 +-
 6 files changed, 466 insertions(+), 135 deletions(-)

diff --git a/src/lv_api_map.h b/src/lv_api_map.h
index 6006216cb..23f7b8894 100644
--- a/src/lv_api_map.h
+++ b/src/lv_api_map.h
@@ -212,17 +212,17 @@ static inline void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * se
 static inline void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs,
                                       lv_coord_t y_ofs)
 {
-    lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
+//    lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
 }
 
 static inline void lv_obj_align_origo_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
 {
-    lv_obj_align_mid_y(obj, base, align, x_ofs);
+//    lv_obj_align_mid_y(obj, base, align, x_ofs);
 }
 
 static inline void lv_obj_align_origo_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
 {
-    lv_obj_align_mid_y(obj, base, align, y_ofs);
+//    lv_obj_align_mid_y(obj, base, align, y_ofs);
 }
 
 #endif /*LV_USE_API_EXTENSION_V6*/
diff --git a/src/lv_core/lv_align.c b/src/lv_core/lv_align.c
index a9ed4cf83..2a7d35ca7 100644
--- a/src/lv_core/lv_align.c
+++ b/src/lv_core/lv_align.c
@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_align.h"
+#include "lv_obj.h"
 
 /*********************
  *      DEFINES
@@ -19,6 +20,12 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc);
+static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc);
+
+static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 
 /**********************
  *  STATIC VARIABLES
@@ -32,23 +39,17 @@
  *   GLOBAL FUNCTIONS
  **********************/
 
-void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc)
+void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc)
 {
-    calc->col_dsc_len = grid->col_dsc_len + 1;
-    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
-    calc->row_dsc_len = grid->row_dsc_len + 1;
-    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+    static uint32_t cnt = 0;
+    cnt++;
+    if(obj->grid == NULL) return;
 
-    calc->col_dsc[0] = 0;
-    calc->row_dsc[0] = 0;
+    printf("calc: %d (size: %d)\n", cnt, obj->grid->col_dsc_len);
+
+    if(obj->grid->col_dsc && obj->grid->row_dsc) calc_explicit(obj, calc);
+    else if(obj->grid->col_dsc && !obj->grid->row_dsc) calc_flow_row(obj, calc);
 
-    uint8_t i;
-    for(i = 0; i < grid->col_dsc_len; i++) {
-        calc->col_dsc[i + 1] = calc->col_dsc[i] + grid->col_dsc[i];
-    }
-    for(i = 0; i < grid->row_dsc_len; i++) {
-        calc->row_dsc[i + 1] = calc->row_dsc[i] + grid->row_dsc[i];
-    }
 }
 
 void grid_calc_free(_lv_grid_calc_t * calc)
@@ -57,30 +58,182 @@ void grid_calc_free(_lv_grid_calc_t * calc)
     _lv_mem_buf_release(calc->row_dsc);
 }
 
-uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t col)
-{
-    lv_coord_t x;
-    /*If explicitly defined get the column size else use the first column*/
-    if(col < grid->col_dsc_len) x = grid->col_dsc[col];
-    else x = grid->col_dsc[0];
 
-    if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
-    else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
-    else return _GRID_CELL_SIZE_PX;
+bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
+{
+    if(obj->grid == NULL) return false;
+    if(obj->grid->col_dsc == NULL)  return false;
+
+    uint32_t i;
+    for(i = 0; i < obj->grid->col_dsc_len; i++) {
+        if(_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
+    }
+
+    return false;
 }
 
-uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t row)
+bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
 {
-    lv_coord_t x;
-    /*If explicitly defined get the row size else use the first row*/
-    if(row < grid->row_dsc_len) x = grid->row_dsc[row];
-    else x = grid->row_dsc[0];
+    if(obj->grid == NULL) return false;
+    if(obj->grid->row_dsc == NULL)  return false;
 
-    if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
-    else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
-    else return _GRID_CELL_SIZE_PX;
+    uint32_t i;
+    for(i = 0; i < obj->grid->row_dsc_len; i++) {
+        if(_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
+    }
+
+    return false;
 }
 
 /**********************
  *   STATIC FUNCTIONS
  **********************/
+
+static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc)
+{
+    calc_explicit_rows(obj, calc);
+    calc_explicit_cols(obj, calc);
+
+}
+
+
+static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc)
+{
+    calc_explicit_cols(obj, calc);
+    calc_implicit_rows(obj, calc);
+}
+
+
+static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
+{
+    lv_grid_t * grid = cont->grid;
+    uint32_t i;
+
+    lv_coord_t * cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->col_dsc_len);
+    uint32_t col_fr_cnt = 0;
+    lv_coord_t grid_w = 0;
+    bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
+
+    for(i = 0; i < grid->col_dsc_len; i++) {
+        lv_coord_t x = grid->col_dsc[i];
+        if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
+        else {
+            cols_w[i] = x;
+            grid_w += x;
+        }
+    }
+
+    lv_coord_t free_w = lv_obj_get_width_fit(cont) - grid_w;
+
+
+    for(i = 0; i < grid->col_dsc_len; i++) {
+        lv_coord_t x = grid->col_dsc[i];
+        if(_GRID_IS_FR(x)) {
+            if(auto_w) cols_w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
+            else {
+                lv_coord_t f = _GRID_GET_FR(x);
+                cols_w[i] = (free_w * f) / col_fr_cnt;
+            }
+        }
+    }
+
+    calc->col_dsc_len = grid->col_dsc_len + 1;
+    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
+
+    calc->col_dsc[0] = 0;
+    for(i = 0; i < grid->col_dsc_len; i++) {
+        calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
+    }
+    _lv_mem_buf_release(cols_w);
+}
+
+static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
+{
+    lv_grid_t * grid = cont->grid;
+    uint32_t i;
+    calc_explicit_cols(cont, calc);
+
+    lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->row_dsc_len);
+    uint32_t row_fr_cnt = 0;
+    lv_coord_t grid_h = 0;
+
+    bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
+
+
+    for(i = 0; i < grid->row_dsc_len; i++) {
+        lv_coord_t x = grid->row_dsc[i];
+        if(_GRID_IS_FR(x)) row_fr_cnt += _GRID_GET_FR(x);
+        else {
+            rows_h[i] = x;
+            grid_h += x;
+        }
+    }
+
+    lv_coord_t free_h = lv_obj_get_height_fit(cont) - grid_h;
+
+    for(i = 0; i < grid->row_dsc_len; i++) {
+        lv_coord_t x = grid->row_dsc[i];
+        if(_GRID_IS_FR(x)) {
+            if(auto_h) rows_h[i] = 0;   /*Fr is considered zero if the obj has auto height*/
+            else {
+                lv_coord_t f = _GRID_GET_FR(x);
+                rows_h[i] = (free_h * f) / row_fr_cnt;
+            }
+        }
+    }
+
+    calc->row_dsc_len = grid->row_dsc_len + 1;
+    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+
+    calc->row_dsc[0] = 0;
+
+
+    for(i = 0; i < grid->row_dsc_len; i++) {
+        calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
+    }
+
+    _lv_mem_buf_release(rows_h);
+}
+
+
+static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
+{
+
+    lv_grid_t * grid = cont->grid;
+
+    uint32_t child_cnt = lv_obj_count_children(cont);
+
+    uint32_t row_cnt = (child_cnt / grid->col_dsc_len) + 1;
+    /*At worst case all children is gird item prepare place for all of them*/
+    lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * row_cnt);
+    _lv_memset_00(rows_h, sizeof(lv_coord_t) * row_cnt);
+
+    uint32_t i;
+
+    lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+    uint32_t col_i = 0;
+    uint32_t row_i = 0;
+    while(child) {
+        if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+            rows_h[row_i] = LV_MATH_MAX(rows_h[row_i], lv_obj_get_height(child));
+            col_i++;
+            if(col_i == grid->col_dsc_len) {
+                col_i = 0;
+                row_i++;
+            }
+        }
+        child = lv_obj_get_child_back(cont, child);
+    }
+
+
+    calc->row_dsc_len = row_cnt + 1;
+    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+
+    calc->row_dsc[0] = 0;
+
+    for(i = 0; i < row_cnt; i++) {
+        calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
+    }
+
+    _lv_mem_buf_release(rows_h);
+}
diff --git a/src/lv_core/lv_align.h b/src/lv_core/lv_align.h
index c32e422a6..ceb91b597 100644
--- a/src/lv_core/lv_align.h
+++ b/src/lv_core/lv_align.h
@@ -44,14 +44,13 @@ extern "C" {
 
 #define _GRID_CELL_SIZE_PX    0     /* The cell size is set in pixels*/
 #define _GRID_CELL_SIZE_FR    1     /* The cell size is set in free units*/
-#define _GRID_CELL_SIZE_AUTO  2     /* The cell size is automatically set to content*/
 
 #define LV_GRID_FR(x)   (LV_COORD_MAX + (x))
-#define LV_GRID_AUTO    LV_COORD_AUTO
 
 #define _GRID_IS_PX(x) ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
 #define _GRID_IS_FR(x) (x > LV_COORD_MAX ? true : false)
 #define _GRID_IS_AUTO(x) (x == LV_GRID_AUTO ? true : false)
+#define _GRID_GET_FR(x) ((x) - LV_COORD_MAX)
 
 
 /**
@@ -62,7 +61,6 @@ extern "C" {
 #define LV_GRID_CELL_END(pos, span)     ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_END))
 #define LV_GRID_CELL_CENTER(pos, span)  ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_CENTER))
 #define LV_GRID_CELL_STRETCH(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_STRETCH))
-
 /**
  * Special LV_GRID_CELL position to flow the object automatically.
  * Both X (column) and Y (row) value needs to be AUTO or explicitly specified*/
@@ -75,6 +73,9 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+/* Can't include lv_obj.h because it includes this header file */
+struct _lv_obj_t;
+
 /**
  * Describe how to flow LV_GRID_POS_AUTO elements
  */
@@ -97,8 +98,8 @@ typedef struct {
 typedef struct {
     lv_coord_t * col_dsc;
     lv_coord_t * row_dsc;
-    uint8_t col_dsc_len;
-    uint8_t row_dsc_len;
+    uint32_t col_dsc_len;
+    uint32_t row_dsc_len;
 }_lv_grid_calc_t;
 
 /**********************
@@ -111,13 +112,13 @@ void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv
 
 void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
 
-void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc);
+void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc);
 
 void grid_calc_free(_lv_grid_calc_t * calc);
 
-uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t row);
+bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
 
-uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t col);
+bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 7f19e3865..7f450224b 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -295,6 +295,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
             new_obj->coords.x1    = parent->coords.x1;
             new_obj->coords.x2    = parent->coords.x1 + LV_OBJ_DEF_WIDTH;
         }
+        new_obj->w_set = lv_area_get_width(&new_obj->coords);
+        new_obj->h_set = lv_area_get_height(&new_obj->coords);
     }
 
 
@@ -390,6 +392,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         }
     }
 
+    lv_obj_set_pos(new_obj, 0, 0);
+
     /*Send a signal to the parent to notify it about the new child*/
     if(parent != NULL) {
         parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, new_obj);
@@ -641,7 +645,7 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
     }
 
     /*Notify the original parent because one of its children is lost*/
-    old_par->signal_cb(old_par, LV_SIGNAL_CHILD_CHG, NULL);
+    old_par->signal_cb(old_par, LV_SIGNAL_CHILD_CHG, obj);
 
     /*Notify the new parent about the child*/
     parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
@@ -699,17 +703,17 @@ void lv_obj_move_background(lv_obj_t * obj)
  * Coordinate set
  * ------------------*/
 
-static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+static void move_obj_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent)
 {
     /*Convert x and y to absolute coordinates*/
-    lv_obj_t * par = obj->parent;
+    lv_obj_t * parent = obj->parent;
 
-    if(par) {
-        lv_coord_t pad_left = lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
-        lv_coord_t pad_top = lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
+    if(parent) {
+        lv_coord_t pad_left = lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
+        lv_coord_t pad_top = lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
 
-        x += pad_left + par->coords.x1 - lv_obj_get_scroll_left(par);
-        y += pad_top + par->coords.y1 - lv_obj_get_scroll_top(par);
+        x += pad_left + parent->coords.x1 - lv_obj_get_scroll_left(parent);
+        y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
     } else {
         /*If no parent then it's screen but screen can't be on a grid*/
         if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
@@ -748,7 +752,7 @@ static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
 
     /*Send a signal to the parent too*/
-    if(par) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
+    if(parent && notify_parent) parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
 
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
@@ -757,15 +761,12 @@ static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 
 static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 {
-
     /* Do nothing if the size is not changed */
     /* It is very important else recursive resizing can
      * occur without size change*/
     if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
         return false;
     }
-
-
     /*Invalidate the original area*/
     lv_obj_invalidate(obj);
 
@@ -797,77 +798,165 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
-
     return true;
 }
 
+bool lv_obj_is_grid_item(lv_obj_t * obj);
+static void lv_grid_full_refr(lv_obj_t * cont);
 
-
-static void lv_grid_refresh_item_pos(lv_obj_t * obj)
+static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc)
 {
-    /*Calculate the grid*/
-    lv_obj_t * parent = lv_obj_get_parent(obj);
-    lv_coord_t * col_dsc;
-    lv_coord_t * row_dsc;
-    uint8_t col_num;
-    uint8_t row_num;
-    _lv_grid_calc_t calc;
-    grid_calc(parent->grid, &calc);
+    if(lv_obj_is_grid_item(item) == false) return;
 
-    uint8_t col_pos = _GRID_GET_CELL_POS(obj->x_set);
-    uint8_t col_span = _GRID_GET_CELL_SPAN(obj->x_set);
-    uint8_t row_pos = _GRID_GET_CELL_POS(obj->y_set);
-    uint8_t row_span = _GRID_GET_CELL_SPAN(obj->y_set);
+    uint8_t col_pos;
+    uint8_t col_span;
+    uint8_t row_pos;
+    uint8_t row_span;
 
-    lv_coord_t col_w = calc.col_dsc[col_pos + col_span] - calc.col_dsc[col_pos];
-    lv_coord_t row_h = calc.row_dsc[row_pos + row_span] - calc.row_dsc[row_pos];
+    if(cont->grid->row_dsc && cont->grid->col_dsc) {
+        col_pos = _GRID_GET_CELL_POS(item->x_set);
+        col_span = _GRID_GET_CELL_SPAN(item->x_set);
+        row_pos = _GRID_GET_CELL_POS(item->y_set);
+        row_span = _GRID_GET_CELL_SPAN(item->y_set);
+    } else {
+        col_span = 1;
+        row_span = 1;
 
-    uint8_t x_flag = _GRID_GET_CELL_FLAG(obj->x_set);
-    uint8_t y_flag = _GRID_GET_CELL_FLAG(obj->y_set);
+        uint32_t child_id = 0;
+        lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+
+        while(child) {
+            if(child == item) break;
+            if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+                child_id++;
+            }
+            child = lv_obj_get_child_back(cont, child);
+        }
+
+        col_pos = child_id % cont->grid->col_dsc_len;
+        row_pos = child_id / cont->grid->col_dsc_len;
+    }
+
+    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
+    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
+
+    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
+    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
 
     lv_coord_t x;
     lv_coord_t y;
-    lv_coord_t w = lv_obj_get_width(obj);
-    lv_coord_t h = lv_obj_get_height(obj);
+    lv_coord_t w = lv_obj_get_width(item);
+    lv_coord_t h = lv_obj_get_height(item);
 
     switch(x_flag) {
         case LV_GRID_START:
-            x = calc.col_dsc[col_pos];
+            x = calc->col_dsc[col_pos];
             break;
         case LV_GRID_STRETCH:
-            x = calc.col_dsc[col_pos];
+            x = calc->col_dsc[col_pos];
             w = col_w;
+            item->w_set = LV_SIZE_STRETCH;
             break;
         case LV_GRID_CENTER:
-            x = calc.col_dsc[col_pos] + (col_w - w) / 2;
+            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
             break;
         case LV_GRID_END:
-            x = calc.col_dsc[col_pos + 1] - lv_obj_get_width(obj);
+            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
             break;
     }
 
     switch(y_flag) {
         case LV_GRID_START:
-            y = calc.row_dsc[row_pos];
+            y = calc->row_dsc[row_pos];
             break;
         case LV_GRID_STRETCH:
-            y = calc.row_dsc[row_pos];
+            y = calc->row_dsc[row_pos];
+            item->h_set = LV_SIZE_STRETCH;
             h = row_h;
             break;
         case LV_GRID_CENTER:
-            y = calc.row_dsc[row_pos] + (row_h - h) / 2;
+            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
             break;
         case LV_GRID_END:
-            y = calc.row_dsc[row_pos + 1] - lv_obj_get_height(obj);
+            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
             break;
     }
 
-    refr_pos(obj, x, y);
-    refr_size(obj, w, h);
+    /*Set a new size if required*/
+    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
+        lv_area_t old_coords;
+        lv_area_copy(&old_coords, &item->coords);
+        lv_obj_invalidate(item);
+        lv_area_set_width(&item->coords, w);
+        lv_area_set_height(&item->coords, h);
+        lv_obj_invalidate(item);
+        item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
+
+        /* If a children is a grid container and has an FR field it also needs to be updated
+         * because the FR cell size will change with child size change. */
+        lv_obj_t * child = lv_obj_get_child(item, NULL);
+        while(child) {
+            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
+                lv_grid_full_refr(child);
+            }
+            child = lv_obj_get_child(item, child);
+        }
+    }
+
+    move_obj_to(item, x, y, false);
+}
+
+bool lv_obj_is_content_sensitive(lv_obj_t * item)
+{
+    if(lv_obj_is_grid_item(item) == false) return false;
+    lv_obj_t * cont = lv_obj_get_parent(item);
+
+    if(cont->grid->col_dsc == NULL && _GRID_GET_CELL_FLAG(item->x_set) == LV_GRID_STRETCH) return true;
+    if(cont->grid->row_dsc == NULL && _GRID_GET_CELL_FLAG(item->y_set) == LV_GRID_STRETCH) return true;
+
+    return false;
+}
+
+static void lv_grid_full_refr(lv_obj_t * cont)
+{
+    /*Calculate the grid*/
+    if(cont->grid == NULL) return;
+    _lv_grid_calc_t calc;
+    grid_calc(cont, &calc);
+
+    lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
+    while(item) {
+        _grid_item_repos(cont, item, &calc);
+        item = lv_obj_get_child_back(cont, item);
+    }
+    grid_calc_free(&calc);
+
+    if(cont->w_set == LV_SIZE_AUTO || cont->h_set == LV_SIZE_AUTO) {
+        lv_obj_set_size(cont, cont->w_set, cont->h_set);
+    }
+}
+
+static void lv_grid_item_refr_pos(lv_obj_t * item)
+{
+    /*Calculate the grid*/
+    lv_obj_t * cont = lv_obj_get_parent(item);
+    if(cont->grid == NULL) return;
+    _lv_grid_calc_t calc;
+    grid_calc(cont, &calc);
+
+    _grid_item_repos(cont, item, &calc);
 
     grid_calc_free(&calc);
 }
 
+bool lv_obj_is_grid_item(lv_obj_t * obj)
+{
+    lv_obj_t * cont = lv_obj_get_parent(obj);
+    if(cont == NULL) return false;
+    if(cont->grid == NULL) return false;
+    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->y_set)) return true;
+    return false;
+}
 
 /**
  * Set relative the position of an object (relative to the parent)
@@ -882,11 +971,34 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->x_set = x;
     obj->y_set = y;
 
-    /*If the object is on a grid item let grid to position it. */
-    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->x_set)) {
-        lv_grid_refresh_item_pos(obj);
+    bool gi = lv_obj_is_grid_item(obj);
+
+    /*For consistency set the size to stretched if the objects is stretched on the grid*/
+    if(gi) {
+        if(_GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
+        if(_GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
+    }
+
+    /*If not grid item but has grid position set the position to 0*/
+    if(!gi) {
+        if(_GRID_IS_CELL(x)) {
+            obj->x_set = 0;
+            x = 0;
+        }
+        if(_GRID_IS_CELL(y)) {
+            obj->y_set = 0;
+            y = 0;
+        }
+    }
+
+    /*If the object is on a grid item let the grid to position it. */
+    if(gi) {
+        lv_obj_t * cont = lv_obj_get_parent(obj);
+        /*If added to a grid with auto flow refresh the whole grid else just this item*/
+        if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) lv_grid_full_refr(cont);
+        else lv_grid_item_refr_pos(obj);
     } else {
-        refr_pos(obj, x, y);
+        move_obj_to(obj, x, y, true);
     }
 }
 
@@ -914,6 +1026,52 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
     lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
 }
 
+void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
+{
+    if(!w && !h) return;
+
+    static uint32_t cnt = 0;
+    printf("auto_size: %d\n", cnt);
+    cnt++;
+    /*If no other effect the auto-size of zero by default*/
+    if(w) *w = 0;
+    if(h) *h = 0;
+
+    /*Get the grid size of the object has a defined grid*/
+    lv_coord_t grid_w = 0;
+    lv_coord_t grid_h = 0;
+    if(obj->grid) {
+        _lv_grid_calc_t calc;
+        grid_calc(obj, &calc);
+        grid_w = calc.col_dsc[calc.col_dsc_len - 1];
+        grid_h = calc.row_dsc[calc.row_dsc_len - 1];
+        grid_calc_free(&calc);
+    }
+
+    /*Get the children's most right and bottom position*/
+    lv_coord_t children_w = 0;
+    lv_coord_t children_h = 0;
+    if(w) {
+        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
+        children_w = lv_obj_get_width(obj) + scroll_right;
+    }
+
+    if(h) {
+        static uint32_t cnt = 0;
+//        printf("auto_size_scrl: %d\n", cnt);
+        cnt++;
+        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
+        children_h = lv_obj_get_height(obj) + scroll_bottom;
+    }
+
+
+    /*auto_size = max(gird_size, children_size)*/
+    if(w) *w = LV_MATH_MAX(children_w, grid_w);
+    if(h) *h = LV_MATH_MAX(children_h, grid_h);
+}
+
 /**
  * Set the size of an object
  * @param obj pointer to an object
@@ -924,55 +1082,47 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
+    bool gi = lv_obj_is_grid_item(obj);
+    bool x_stretch = false;
+    bool y_stretch = false;
+
+    if(gi) {
+        x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
+        y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
+        if(x_stretch) w = LV_SIZE_STRETCH;
+        if(y_stretch) h = LV_SIZE_STRETCH;
+    }
+
     obj->w_set = w;
     obj->h_set = h;
 
-    /*If the object is a grid element and stretched, prevent settings its size */
-    bool x_stretch = false;
-    bool y_stretch = false;
-    x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
-    y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
-
+    /*If both streched it was alraedy managed by the grid*/
     if(x_stretch && y_stretch) return;
 
-    lv_coord_t grid_w = 0;
-    lv_coord_t grid_h = 0;
-    if(((LV_COORD_IS_AUTO(obj->w_set) && !x_stretch) ||
-        (LV_COORD_IS_AUTO(obj->h_set) && !y_stretch))) {
-        _lv_grid_calc_t calc;
-        grid_calc(obj->grid, &calc);
-        grid_w = calc.col_dsc[calc.col_dsc_len - 1];
-        grid_h = calc.row_dsc[calc.row_dsc_len - 1];
-        grid_calc_free(&calc);
-    }
-
-
     if(x_stretch) w = lv_obj_get_width(obj);
-    else {
-        if(LV_COORD_IS_AUTO(obj->w_set)) {
-            lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
-            lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
-            w = lv_obj_get_width(obj) + scroll_right;
-            w = LV_MATH_MAX(w, grid_w);
-        }
-    }
-
     if(y_stretch) h = lv_obj_get_height(obj);
-    else {
-        if(LV_COORD_IS_AUTO(obj->h_set) && !x_stretch) {
-            lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
-            lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
-            h = lv_obj_get_height(obj) + scroll_bottom;
-            h = LV_MATH_MAX(h, grid_h);
-        }
+
+    /*Calculate the required auto sizes*/
+    bool x_auto = obj->w_set == LV_SIZE_AUTO ? true : false;
+    bool y_auto = obj->h_set == LV_SIZE_AUTO ? true : false;
+
+    lv_coord_t auto_w;
+    lv_coord_t auto_h;
+    if(x_auto && y_auto) {
+        _lv_obj_calc_auto_size(obj, &auto_w, &auto_h);
+        w = auto_w;
+        h = auto_h;
+    }
+    else if(x_auto) {
+        _lv_obj_calc_auto_size(obj, &auto_w, NULL);
+        w = auto_w;
+    }
+    else if(y_auto) {
+        _lv_obj_calc_auto_size(obj, NULL, &auto_h);
+        h = auto_h;
     }
 
     bool chg = refr_size(obj, w, h);
-
-    /*Refresh the position in the grid item if required*/
-    if(chg && (_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->y_set))) {
-        lv_grid_refresh_item_pos(obj);
-    }
 }
 
 /**
@@ -1528,7 +1678,7 @@ void lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop
             case LV_STYLE_MARGIN_BOTTOM:
             case LV_STYLE_MARGIN_LEFT:
             case LV_STYLE_MARGIN_RIGHT:
-                if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, NULL);
+                if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, obj);
                 break;
         }
 
@@ -3909,8 +4059,6 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
         }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
-
-
         scrollbar_draw(obj, clip_area);
 
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
@@ -3979,9 +4127,34 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 
     lv_res_t res = LV_RES_OK;
 
-    if(sign == LV_SIGNAL_CHILD_CHG) {
+    if(sign == LV_SIGNAL_COORD_CHG) {
+        if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
+           (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
+        {
+            lv_grid_full_refr(obj);
+        }
+    }
+    else 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;
+
+        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
+            lv_obj_set_size(obj, obj->w_set, obj->h_set);
+        }
+
+        if(obj->grid) {
+            lv_obj_t * child = param;
+            if(child) {
+                if(lv_obj_is_grid_item(child)) lv_grid_full_refr(obj);
+            } else {
+                lv_grid_full_refr(obj);
+            }
+        }
+
+//        else if(lv_obj_is_content_sensitive(obj)) {
+//                lv_grid_full_refr(lv_obj_get_parent(obj));
+//        }
+
     }
     else if(sign == LV_SIGNAL_SCROLL) {
 
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 9c0ee22fc..ffbfbbcff 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -422,6 +422,9 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x);
  */
 void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y);
 
+
+void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h);
+
 /**
  * Set the size of an object
  * @param obj pointer to an object
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index 86ee4a186..49fd59c1c 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -210,10 +210,11 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
  **********************/
 
 #define LV_COORD_PX(x)  (x)
-#define LV_COORD_AUTO (LV_COORD_MAX - 1)
+#define LV_SIZE_AUTO (LV_COORD_MAX - 1)
+#define LV_SIZE_STRETCH (LV_COORD_MAX - 2)
 
-#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX) ? true : false)
-#define LV_COORD_IS_AUTO(x) (((x) == LV_COORD_AUTO) ? true : false)
+#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX - 2) ? true : false)
+#define LV_COORD_IS_AUTO(x) (((x) == LV_SIZE_AUTO) ? true : false)
 
 
 #ifdef __cplusplus

From 67d268b3ee114817fb5d6902dc3c52ff01540ace Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 31 Aug 2020 09:33:44 +0200
Subject: [PATCH 20/84] gird optimization

---
 src/lv_core/lv_core.mk                |   1 +
 src/lv_core/{lv_align.c => lv_grid.c} | 152 ++++++++++++++-----
 src/lv_core/{lv_align.h => lv_grid.h} |   6 +-
 src/lv_core/lv_obj.c                  | 203 ++++++++++++++++++--------
 src/lv_core/lv_obj.h                  |   2 +-
 src/lv_core/lv_refr.c                 |   2 +-
 src/lv_core/lv_style.c                |   7 +
 src/lv_core/lv_style.h                |   3 +-
 src/lv_misc/lv_anim.c                 |   4 +-
 src/lv_misc/lv_ll.c                   |  35 -----
 src/lv_misc/lv_ll.h                   |  10 +-
 src/lv_misc/lv_mem.c                  |  51 +++----
 12 files changed, 308 insertions(+), 168 deletions(-)
 rename src/lv_core/{lv_align.c => lv_grid.c} (54%)
 rename src/lv_core/{lv_align.h => lv_grid.h} (98%)

diff --git a/src/lv_core/lv_core.mk b/src/lv_core/lv_core.mk
index b46c01625..9f15199bd 100644
--- a/src/lv_core/lv_core.mk
+++ b/src/lv_core/lv_core.mk
@@ -1,3 +1,4 @@
+CSRCS += lv_grid.c
 CSRCS += lv_group.c
 CSRCS += lv_indev.c
 CSRCS += lv_disp.c
diff --git a/src/lv_core/lv_align.c b/src/lv_core/lv_grid.c
similarity index 54%
rename from src/lv_core/lv_align.c
rename to src/lv_core/lv_grid.c
index 2a7d35ca7..6d4b3665b 100644
--- a/src/lv_core/lv_align.c
+++ b/src/lv_core/lv_grid.c
@@ -6,12 +6,13 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_align.h"
+#include "lv_grid.h"
 #include "lv_obj.h"
 
 /*********************
  *      DEFINES
  *********************/
+#define CALC_DSC_BUF_SIZE   8
 
 /**********************
  *      TYPEDEFS
@@ -20,16 +21,18 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc);
-static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc);
-
 static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
+static lv_coord_t col_dsc_calc_buf[CALC_DSC_BUF_SIZE];
+static lv_coord_t row_dsc_calc_buf[CALC_DSC_BUF_SIZE];
+static bool col_dsc_buf_used;
+static bool row_dsc_buf_used;
 
 /**********************
  *      MACROS
@@ -41,14 +44,24 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 
 void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc)
 {
-    static uint32_t cnt = 0;
-    cnt++;
     if(obj->grid == NULL) return;
 
-    printf("calc: %d (size: %d)\n", cnt, obj->grid->col_dsc_len);
+//    static uint32_t cnt = 0;
+//    cnt++;
+//    printf("calc: %d (size: %d)\n", cnt, obj->grid->col_dsc_len);
 
-    if(obj->grid->col_dsc && obj->grid->row_dsc) calc_explicit(obj, calc);
-    else if(obj->grid->col_dsc && !obj->grid->row_dsc) calc_flow_row(obj, calc);
+    if(obj->grid->col_dsc && obj->grid->row_dsc) {
+        calc_explicit_rows(obj, calc);
+        calc_explicit_cols(obj, calc);
+    }
+    else if(obj->grid->col_dsc && !obj->grid->row_dsc) {
+        calc_explicit_cols(obj, calc);
+        calc_implicit_rows(obj, calc);
+    }
+    else if(!obj->grid->col_dsc && obj->grid->row_dsc) {
+        calc_implicit_cols(obj, calc);
+        calc_explicit_rows(obj, calc);
+    }
 
 }
 
@@ -89,27 +102,19 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
  *   STATIC FUNCTIONS
  **********************/
 
-static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc)
-{
-    calc_explicit_rows(obj, calc);
-    calc_explicit_cols(obj, calc);
-
-}
-
-
-static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc)
-{
-    calc_explicit_cols(obj, calc);
-    calc_implicit_rows(obj, calc);
-}
-
-
 static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
     lv_grid_t * grid = cont->grid;
     uint32_t i;
 
-    lv_coord_t * cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->col_dsc_len);
+    lv_coord_t * cols_w;
+    if(!col_dsc_buf_used && grid->col_dsc_len <= CALC_DSC_BUF_SIZE) {
+        cols_w = col_dsc_calc_buf;
+        col_dsc_buf_used = true;
+    } else {
+        cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->col_dsc_len);
+    }
+
     uint32_t col_fr_cnt = 0;
     lv_coord_t grid_w = 0;
     bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
@@ -144,16 +149,24 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
     for(i = 0; i < grid->col_dsc_len; i++) {
         calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
     }
-    _lv_mem_buf_release(cols_w);
+
+    if(col_dsc_buf_used) col_dsc_buf_used = false ;
+    else _lv_mem_buf_release(cols_w);
 }
 
 static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
     lv_grid_t * grid = cont->grid;
     uint32_t i;
-    calc_explicit_cols(cont, calc);
 
-    lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->row_dsc_len);
+    lv_coord_t * rows_h;
+    if(!row_dsc_buf_used && grid->row_dsc_len <= CALC_DSC_BUF_SIZE) {
+        rows_h = row_dsc_calc_buf;
+        row_dsc_buf_used = true;
+    } else {
+        rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->row_dsc_len);
+    }
+
     uint32_t row_fr_cnt = 0;
     lv_coord_t grid_h = 0;
 
@@ -192,7 +205,65 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
         calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
     }
 
-    _lv_mem_buf_release(rows_h);
+    if(row_dsc_buf_used) row_dsc_buf_used = false;
+    else _lv_mem_buf_release(rows_h);
+}
+
+
+static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
+{
+    lv_grid_t * grid = cont->grid;
+
+    uint32_t child_cnt = lv_obj_count_children(cont);
+
+    uint32_t col_cnt = (child_cnt / grid->row_dsc_len) + 1;
+    /* If `col_dsc_buf_used`, nested a call of this func. will release `col_dsc_buf_used` because it think it taken it.
+     * So mark that if the buffer was taken in this call*/
+    bool col_dsc_buf_mine = false;
+    /*At worst case all children is gird item prepare place for all of them*/
+    lv_coord_t * cols_w;
+    if(!col_dsc_buf_used && col_cnt <= CALC_DSC_BUF_SIZE) {
+        cols_w = col_dsc_calc_buf;
+        col_dsc_buf_used = true;
+        col_dsc_buf_mine = true;
+    } else {
+        cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * col_cnt);
+    }
+
+    uint32_t i;
+
+    lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+    uint32_t row_i = 0;
+    uint32_t col_i = 0;
+    cols_w[0] = 0;
+    while(child) {
+        if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+            lv_coord_t w;
+            if(_GRID_GET_CELL_FLAG(child->x_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  &w, NULL);
+            else w = lv_obj_get_width(child);
+            cols_w[col_i] = LV_MATH_MAX(cols_w[col_i], w);
+            row_i++;
+            if(row_i == grid->row_dsc_len) {
+                row_i = 0;
+                col_i++;
+                cols_w[col_i] = 0;
+            }
+        }
+        child = lv_obj_get_child_back(cont, child);
+    }
+
+
+    calc->col_dsc_len = col_cnt + 1;
+    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
+
+    calc->col_dsc[0] = 0;
+
+    for(i = 0; i < col_cnt; i++) {
+        calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
+    }
+
+    if(col_dsc_buf_used && col_dsc_buf_mine) col_dsc_buf_used = false;
+    else _lv_mem_buf_release(cols_w);
 }
 
 
@@ -200,26 +271,36 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
 
     lv_grid_t * grid = cont->grid;
-
     uint32_t child_cnt = lv_obj_count_children(cont);
-
     uint32_t row_cnt = (child_cnt / grid->col_dsc_len) + 1;
+    bool row_dsc_buf_mine = false;
     /*At worst case all children is gird item prepare place for all of them*/
-    lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * row_cnt);
-    _lv_memset_00(rows_h, sizeof(lv_coord_t) * row_cnt);
+    lv_coord_t * rows_h;
+    if(!row_dsc_buf_used && row_cnt <= CALC_DSC_BUF_SIZE) {
+        rows_h = row_dsc_calc_buf;
+        row_dsc_buf_used = true;
+        row_dsc_buf_mine = true;
+    } else {
+        rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * row_cnt);
+    }
 
     uint32_t i;
 
     lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
     uint32_t col_i = 0;
     uint32_t row_i = 0;
+    rows_h[0] = 0;
     while(child) {
         if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-            rows_h[row_i] = LV_MATH_MAX(rows_h[row_i], lv_obj_get_height(child));
+            lv_coord_t h;
+            if(_GRID_GET_CELL_FLAG(child->y_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  NULL, &h);
+            else h = lv_obj_get_height(child);
+            rows_h[row_i] = LV_MATH_MAX(rows_h[row_i], h);
             col_i++;
             if(col_i == grid->col_dsc_len) {
                 col_i = 0;
                 row_i++;
+                rows_h[row_i] = 0;
             }
         }
         child = lv_obj_get_child_back(cont, child);
@@ -235,5 +316,6 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
         calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
     }
 
-    _lv_mem_buf_release(rows_h);
+    if(row_dsc_buf_used && row_dsc_buf_mine) row_dsc_buf_used = false;
+    else _lv_mem_buf_release(rows_h);
 }
diff --git a/src/lv_core/lv_align.h b/src/lv_core/lv_grid.h
similarity index 98%
rename from src/lv_core/lv_align.h
rename to src/lv_core/lv_grid.h
index ceb91b597..b64576072 100644
--- a/src/lv_core/lv_align.h
+++ b/src/lv_core/lv_grid.h
@@ -3,8 +3,8 @@
  *
  */
 
-#ifndef LV_ALIGN_H
-#define LV_ALIGN_H
+#ifndef LV_GRID_H
+#define LV_GRID_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -128,4 +128,4 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 } /* extern "C" */
 #endif
 
-#endif /*LV_ALIGN_H*/
+#endif /*LV_GRID_H*/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 7f450224b..193d977dd 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -49,6 +49,10 @@
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
 #define SCROLLBAR_MIN_SIZE (LV_DPX(10))
+#define SCROLL_ANIM_TIME_MIN 100    /*ms*/
+#define SCROLL_ANIM_TIME_MAX 300    /*ms*/
+
+#define GRID_DEBUG  1 /*Draw rectangles on grid cells*/
 
 /**********************
  *      TYPEDEFS
@@ -804,14 +808,14 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
 bool lv_obj_is_grid_item(lv_obj_t * obj);
 static void lv_grid_full_refr(lv_obj_t * cont);
 
-static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc)
+static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, uint32_t * child_id_ext, lv_point_t * grid_abs)
 {
     if(lv_obj_is_grid_item(item) == false) return;
 
-    uint8_t col_pos;
-    uint8_t col_span;
-    uint8_t row_pos;
-    uint8_t row_span;
+    uint32_t col_pos;
+    uint32_t col_span;
+    uint32_t row_pos;
+    uint32_t row_span;
 
     if(cont->grid->row_dsc && cont->grid->col_dsc) {
         col_pos = _GRID_GET_CELL_POS(item->x_set);
@@ -823,18 +827,26 @@ static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t *
         row_span = 1;
 
         uint32_t child_id = 0;
-        lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+        if(child_id_ext) child_id = *child_id_ext;
+        else {
+            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
 
-        while(child) {
-            if(child == item) break;
-            if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-                child_id++;
+            while(child) {
+                if(child == item) break;
+                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+                    child_id++;
+                }
+                child = lv_obj_get_child_back(cont, child);
             }
-            child = lv_obj_get_child_back(cont, child);
         }
 
-        col_pos = child_id % cont->grid->col_dsc_len;
-        row_pos = child_id / cont->grid->col_dsc_len;
+        if(cont->grid->row_dsc == NULL) {
+            col_pos = child_id % cont->grid->col_dsc_len;
+            row_pos = child_id / cont->grid->col_dsc_len;
+        } else {
+            col_pos = child_id / cont->grid->row_dsc_len;
+            row_pos = child_id % cont->grid->row_dsc_len;
+        }
     }
 
     lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
@@ -902,19 +914,12 @@ static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t *
             child = lv_obj_get_child(item, child);
         }
     }
+    bool moved = true;
+    if(grid_abs) {
+        if(grid_abs->x + x == item->coords.x1 && grid_abs->y + y == item->coords.y1) moved = false;
+    }
 
-    move_obj_to(item, x, y, false);
-}
-
-bool lv_obj_is_content_sensitive(lv_obj_t * item)
-{
-    if(lv_obj_is_grid_item(item) == false) return false;
-    lv_obj_t * cont = lv_obj_get_parent(item);
-
-    if(cont->grid->col_dsc == NULL && _GRID_GET_CELL_FLAG(item->x_set) == LV_GRID_STRETCH) return true;
-    if(cont->grid->row_dsc == NULL && _GRID_GET_CELL_FLAG(item->y_set) == LV_GRID_STRETCH) return true;
-
-    return false;
+    if(moved) move_obj_to(item, x, y, false);
 }
 
 static void lv_grid_full_refr(lv_obj_t * cont)
@@ -924,9 +929,21 @@ static void lv_grid_full_refr(lv_obj_t * cont)
     _lv_grid_calc_t calc;
     grid_calc(cont, &calc);
 
+    /* Calculate the grids absolute x and y coordinates.
+     * It will be used as helper during item repositioning to avoid calculating this value for every children*/
+    lv_point_t grid_abs;
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_top = lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN);
+    grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
+    grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
+
+    uint32_t child_id = 0;
     lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
     while(item) {
-        _grid_item_repos(cont, item, &calc);
+        if(_GRID_IS_CELL(item->x_set) && _GRID_IS_CELL(item->y_set)) {
+            _grid_item_repos(cont, item, &calc, &child_id, &grid_abs);
+            child_id++;
+        }
         item = lv_obj_get_child_back(cont, item);
     }
     grid_calc_free(&calc);
@@ -944,7 +961,7 @@ static void lv_grid_item_refr_pos(lv_obj_t * item)
     _lv_grid_calc_t calc;
     grid_calc(cont, &calc);
 
-    _grid_item_repos(cont, item, &calc);
+    _grid_item_repos(cont, item, &calc, NULL, NULL);
 
     grid_calc_free(&calc);
 }
@@ -993,10 +1010,18 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 
     /*If the object is on a grid item let the grid to position it. */
     if(gi) {
+        lv_area_t old_area;
+        lv_area_copy(&old_area, &obj->coords);
+        lv_grid_item_refr_pos(obj);
+
         lv_obj_t * cont = lv_obj_get_parent(obj);
-        /*If added to a grid with auto flow refresh the whole grid else just this item*/
-        if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) lv_grid_full_refr(cont);
-        else lv_grid_item_refr_pos(obj);
+
+        /*If the item was moved and grid is implicit in the changed direction refresh the whole grid.*/
+        if((cont->grid->col_dsc == NULL && (old_area.x1 != obj->coords.x1 || old_area.x2 != obj->coords.x2)) ||
+           (cont->grid->row_dsc == NULL && (old_area.y1 != obj->coords.y1 || old_area.y2 != obj->coords.y2)))
+        {
+            lv_grid_full_refr(cont);
+        }
     } else {
         move_obj_to(obj, x, y, true);
     }
@@ -1030,9 +1055,10 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
 {
     if(!w && !h) return;
 
-    static uint32_t cnt = 0;
-    printf("auto_size: %d\n", cnt);
-    cnt++;
+//    static uint32_t cnt = 0;
+//    printf("auto_size: %d\n", cnt);
+//    cnt++;
+
     /*If no other effect the auto-size of zero by default*/
     if(w) *w = 0;
     if(h) *h = 0;
@@ -1043,8 +1069,8 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
     if(obj->grid) {
         _lv_grid_calc_t calc;
         grid_calc(obj, &calc);
-        grid_w = calc.col_dsc[calc.col_dsc_len - 1];
-        grid_h = calc.row_dsc[calc.row_dsc_len - 1];
+        grid_w = calc.col_dsc[calc.col_dsc_len - 1] + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+        grid_h = calc.row_dsc[calc.row_dsc_len - 1] + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);;
         grid_calc_free(&calc);
     }
 
@@ -1058,9 +1084,6 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
     }
 
     if(h) {
-        static uint32_t cnt = 0;
-//        printf("auto_size_scrl: %d\n", cnt);
-        cnt++;
         lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
         lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
         children_h = lv_obj_get_height(obj) + scroll_bottom;
@@ -1122,7 +1145,7 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
         h = auto_h;
     }
 
-    bool chg = refr_size(obj, w, h);
+    refr_size(obj, w, h);
 }
 
 /**
@@ -1261,7 +1284,10 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
         lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
 
         if(x) {
-            lv_anim_set_time(&a, lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 3) >> 2, 0, x));
+            uint32_t t = lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 3) >> 2, 0, x);
+            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
+            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
+            lv_anim_set_time(&a, t);
             lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
             lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
             lv_anim_set_path(&a, &path);
@@ -1269,7 +1295,10 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
         }
 
         if(y) {
-            lv_anim_set_time(&a, lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y));
+            uint32_t t = lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y);
+            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
+            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
+            lv_anim_set_time(&a, t);
             lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
             lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
             lv_anim_set_path(&a, &path);
@@ -2332,16 +2361,7 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, const lv_obj_t * child)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_t * result = NULL;
-
-    if(child == NULL) {
-        result = _lv_ll_get_head(&obj->child_ll);
-    }
-    else {
-        result = _lv_ll_get_next(&obj->child_ll, child);
-    }
-
-    return result;
+    return child ? _lv_ll_get_next(&obj->child_ll, child) : _lv_ll_get_head(&obj->child_ll);
 }
 
 /**
@@ -2355,16 +2375,7 @@ lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_t * result = NULL;
-
-    if(child == NULL) {
-        result = _lv_ll_get_tail(&obj->child_ll);
-    }
-    else {
-        result = _lv_ll_get_prev(&obj->child_ll, child);
-    }
-
-    return result;
+    return child ? _lv_ll_get_prev(&obj->child_ll, child) : _lv_ll_get_tail(&obj->child_ll);
 }
 
 /**
@@ -2818,6 +2829,12 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
                 case LV_STYLE_PAD_RIGHT:
                     if(list->pad_all_zero) def = true;
                     break;
+                case LV_STYLE_MARGIN_TOP:
+                case LV_STYLE_MARGIN_BOTTOM:
+                case LV_STYLE_MARGIN_LEFT:
+                case LV_STYLE_MARGIN_RIGHT:
+                    if(list->margin_all_zero) def = true;
+                    break;
                 case LV_STYLE_BG_BLEND_MODE:
                 case LV_STYLE_BORDER_BLEND_MODE:
                 case LV_STYLE_IMAGE_BLEND_MODE:
@@ -4086,6 +4103,47 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             coords.y2 += h;
             lv_draw_rect(&coords, clip_area, &draw_dsc);
         }
+
+#if GRID_DEBUG
+        /*Draw the grid cells*/
+        if(obj->grid) {
+            _lv_grid_calc_t calc;
+            grid_calc(obj, &calc);
+
+            /*Create a color unique to this object. */
+            lv_color_t c = lv_color_hex(((lv_uintptr_t) obj) & 0xFFFFFF);
+
+            lv_draw_rect_dsc_t grid_rect_dsc;
+            lv_draw_rect_dsc_init(&grid_rect_dsc);
+            grid_rect_dsc.bg_color = c;
+            grid_rect_dsc.bg_opa = LV_OPA_20;
+            grid_rect_dsc.border_width = 2;
+            grid_rect_dsc.border_color = c;
+            grid_rect_dsc.border_opa = LV_OPA_70;
+
+            lv_point_t grid_abs;
+            lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+            lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
+            grid_abs.x = pad_left + obj->coords.x1 - lv_obj_get_scroll_left(obj);
+            grid_abs.y = pad_top + obj->coords.y1 - lv_obj_get_scroll_top(obj);
+
+            uint32_t row;
+            uint32_t col;
+            for(row = 0; row < calc.row_dsc_len - 1; row ++) {
+                for(col = 0; col < calc.col_dsc_len - 1; col ++) {
+                    lv_area_t a;
+                    a.x1 = grid_abs.x + calc.col_dsc[col];
+                    a.x2 = grid_abs.x + calc.col_dsc[col + 1];
+                    a.y1 = grid_abs.y + calc.row_dsc[row];
+                    a.y2 = grid_abs.y + calc.row_dsc[row + 1];
+                    lv_draw_rect(&a, clip_area, &grid_rect_dsc);
+                }
+            }
+
+
+            grid_calc_free(&calc);
+        }
+#endif
     }
 
     return LV_DESIGN_RES_OK;
@@ -4194,6 +4252,17 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
+        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+        while(child) {
+            lv_obj_set_pos(child, child->x_set, child->y_set);
+            child = lv_obj_get_child(obj, child);
+        }
+
+
+        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
+            lv_obj_set_size(obj, obj->w_set, obj->h_set);
+        }
+//        if(lv_obj_is_grid_item(obj)) lv_grid_full_refr(lv_obj_get_parent(obj));
         lv_obj_refresh_ext_draw_pad(obj);
     }
     else if(sign == LV_SIGNAL_PRESSED) {
@@ -4956,6 +5025,10 @@ static bool style_prop_is_cacheble(lv_style_property_t prop)
         case LV_STYLE_PAD_BOTTOM:
         case LV_STYLE_PAD_LEFT:
         case LV_STYLE_PAD_RIGHT:
+        case LV_STYLE_MARGIN_TOP:
+        case LV_STYLE_MARGIN_BOTTOM:
+        case LV_STYLE_MARGIN_LEFT:
+        case LV_STYLE_MARGIN_RIGHT:
         case LV_STYLE_BG_BLEND_MODE:
         case LV_STYLE_BORDER_BLEND_MODE:
         case LV_STYLE_IMAGE_BLEND_MODE:
@@ -5035,6 +5108,14 @@ static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
         list->pad_all_zero  = 0;
     }
 
+    list->margin_all_zero  = 1;
+    if(lv_obj_get_style_margin_top(obj, part) != 0 ||
+       lv_obj_get_style_margin_bottom(obj, part) != 0 ||
+       lv_obj_get_style_margin_left(obj, part) != 0 ||
+       lv_obj_get_style_margin_right(obj, part) != 0) {
+        list->margin_all_zero  = 0;
+    }
+
     list->blend_mode_all_normal = 1;
 #if LV_USE_BLEND_MODES
     if(lv_obj_get_style_bg_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index ffbfbbcff..cbfd9aef3 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -18,7 +18,7 @@ extern "C" {
 #include <stddef.h>
 #include <stdbool.h>
 #include "lv_style.h"
-#include "lv_align.h"
+#include "lv_grid.h"
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_color.h"
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index 0765fba27..cde758fa2 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -678,7 +678,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
         draw_dsc.bg_color.full = debug_color.full;
         draw_dsc.bg_opa = LV_OPA_20;
         draw_dsc.border_width = 2;
-        draw_dsc.border_opa = LV_OPA_50;
+        draw_dsc.border_opa = LV_OPA_70;
         draw_dsc.border_color.full = (debug_color.full + 0x13) * 9;
 
         lv_draw_rect(&obj_ext_mask, &obj_ext_mask, &draw_dsc);
diff --git a/src/lv_core/lv_style.c b/src/lv_core/lv_style.c
index 3a2ad6d80..5fc116932 100644
--- a/src/lv_core/lv_style.c
+++ b/src/lv_core/lv_style.c
@@ -1044,6 +1044,7 @@ bool lv_debug_check_style_list(const lv_style_list_t * list)
  *   STATIC FUNCTIONS
  **********************/
 
+static uint32_t stat[256];
 /**
  * Get a property's index (byte index in `style->map`) from a style.
  * Return best matching property's index considering the state of `prop`
@@ -1067,6 +1068,12 @@ LV_ATTRIBUTE_FAST_MEM static inline int32_t get_property_index(const lv_style_t
 
     size_t i = 0;
 
+    stat[prop & 0xFF]++;
+//
+//    if((prop & 0xFF) == LV_STYLE_PAD_TOP) {
+//        printf("pad top\n");
+//    }
+
     uint8_t prop_id;
     while((prop_id = get_style_prop_id(style, i)) != _LV_STYLE_CLOSEING_PROP) {
         if(prop_id == id_to_find) {
diff --git a/src/lv_core/lv_style.h b/src/lv_core/lv_style.h
index 420576dc5..c992388c0 100644
--- a/src/lv_core/lv_style.h
+++ b/src/lv_core/lv_style.h
@@ -231,7 +231,7 @@ typedef struct {
 #if LV_USE_ASSERT_STYLE
     uint32_t sentinel;
 #endif
-    uint32_t style_cnt     : 6;
+    uint32_t style_cnt     : 5;
     uint32_t has_local     : 1;
     uint32_t has_trans     : 1;
     uint32_t skip_trans    : 1;      /*1: Temporally skip the transition style if any*/
@@ -244,6 +244,7 @@ typedef struct {
     uint32_t clip_corner_off       : 1;
     uint32_t transform_all_zero  : 1;
     uint32_t pad_all_zero : 1;
+    uint32_t margin_all_zero : 1;
     uint32_t blend_mode_all_normal : 1;
     uint32_t bg_opa_transp : 1;
     uint32_t bg_opa_cover : 1;
diff --git a/src/lv_misc/lv_anim.c b/src/lv_misc/lv_anim.c
index ed3fd7929..3794593d5 100644
--- a/src/lv_misc/lv_anim.c
+++ b/src/lv_misc/lv_anim.c
@@ -260,7 +260,7 @@ lv_anim_value_t lv_anim_path_ease_in(const lv_anim_path_t * path, const lv_anim_
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 1, 1, 1024);
+    int32_t step = _lv_bezier3(t, 0, 100, 200, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
@@ -287,7 +287,7 @@ lv_anim_value_t lv_anim_path_ease_out(const lv_anim_path_t * path, const lv_anim
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 1023, 1023, 1024);
+    int32_t step = _lv_bezier3(t, 0, 800, 900, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
diff --git a/src/lv_misc/lv_ll.c b/src/lv_misc/lv_ll.c
index 9f25b8f7f..4d3e4dabc 100644
--- a/src/lv_misc/lv_ll.c
+++ b/src/lv_misc/lv_ll.c
@@ -249,37 +249,6 @@ void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool h
     }
 }
 
-/**
- * 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'
@@ -289,8 +258,6 @@ void * _lv_ll_get_tail(const lv_ll_t * ll_p)
  */
 void * _lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
 {
-    if(ll_p == NULL) return NULL;
-
     /* Pointer to the next node is stored in the end of this node.
      * Go there and return the address found there */
     const lv_ll_node_t * n_act_d = n_act;
@@ -306,8 +273,6 @@ void * _lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
  */
 void * _lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
 {
-    if(ll_p == NULL) return NULL;
-
     /* Pointer to the prev. node is stored in the end of this node.
      * Go there and return the address found there */
     const lv_ll_node_t * n_act_d = n_act;
diff --git a/src/lv_misc/lv_ll.h b/src/lv_misc/lv_ll.h
index 906414d16..0fac6a713 100644
--- a/src/lv_misc/lv_ll.h
+++ b/src/lv_misc/lv_ll.h
@@ -98,14 +98,20 @@ void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool h
  * @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);
+static inline void * _lv_ll_get_head(const lv_ll_t * ll_p)
+{
+    return ll_p->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);
+static inline void * _lv_ll_get_tail(const lv_ll_t * ll_p)
+{
+    return ll_p->tail;
+}
 
 /**
  * Return with the pointer of the next node after 'n_act'
diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 7fa3146f8..3ef1bd9ae 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -73,7 +73,7 @@ typedef struct {
  **********************/
 #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, size_t size);
+    static inline void * ent_alloc(lv_mem_ent_t * e, size_t size);
     static void ent_trunc(lv_mem_ent_t * e, size_t size);
 #endif
 
@@ -84,9 +84,9 @@ typedef struct {
     static uint8_t * work_mem;
 #endif
 
-static uint32_t zero_mem; /*Give the address of this variable if 0 byte should be allocated*/
-
+static uint32_t zero_mem;   /*Give the address of this variable if 0 byte should be allocated*/
 #if LV_MEM_CUSTOM == 0
+    static uint8_t * last_mem;  /*Address of the last valid byte*/
     static uint32_t mem_max_size; /*Tracks the maximum total size of memory ever used from the internal heap*/
 #endif
 
@@ -125,7 +125,7 @@ void _lv_mem_init(void)
 #else
     work_mem = (uint8_t *)LV_MEM_ADR;
 #endif
-
+    last_mem = &work_mem[LV_MEM_SIZE - 1];
     lv_mem_ent_t * full = (lv_mem_ent_t *)work_mem;
     full->header.s.used = 0;
     /*The total mem size id reduced by the first header and the close patterns */
@@ -176,13 +176,11 @@ void * lv_mem_alloc(size_t size)
     do {
         /* Get the next entry*/
         e = ent_get_next(e);
-
+        if( e == NULL) break;
         /*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);
+        if(!e->header.s.used && e->header.s.d_size >= size) alloc = ent_alloc(e, size);
+        /* End if the alloc. is successful*/
+    } while(alloc == NULL);
 
 #else
     /*Use custom, user defined malloc function*/
@@ -817,19 +815,15 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_ff(void * dst, size_t len)
  */
 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 */
+    /*NULL means: get the first entry; else get the next after `act_e`*/
+    if(act_e == NULL) return (lv_mem_ent_t *)work_mem;
+    else {
         uint8_t * data = &act_e->first_data;
-        next_e         = (lv_mem_ent_t *)&data[act_e->header.s.d_size];
+        lv_mem_ent_t * next_e = (lv_mem_ent_t *)&data[act_e->header.s.d_size];
 
-        if(&next_e->first_data >= &work_mem[LV_MEM_SIZE]) next_e = NULL;
+        if(&next_e->first_data > last_mem) return NULL;
+        else return next_e;
     }
-
-    return next_e;
 }
 
 /**
@@ -838,20 +832,23 @@ static lv_mem_ent_t * ent_get_next(lv_mem_ent_t * act_e)
  * @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, size_t size)
+static inline void * ent_alloc(lv_mem_ent_t * e, size_t size)
 {
-    void * alloc = NULL;
-    /*If the memory is free and big enough then use it */
-    if(e->header.s.used == 0 && e->header.s.d_size >= size) {
+//    static uint32_t cnt = 0;
+//
+////    if((cnt & 0xFFFF) == 0)
+//        printf("alloc: %d\n", cnt);
+//    cnt++;
+//
+
+
         /*Truncate the entry to the desired size */
         ent_trunc(e, size);
         e->header.s.used = 1;
 
         /*Save the allocated data*/
-        alloc = &e->first_data;
-    }
+        return &e->first_data;
 
-    return alloc;
 }
 
 /**

From 075fe54537e4b5623999670dfab54acd0008c54f Mon Sep 17 00:00:00 2001
From: rockindy <yuming.chang@iot-hmi.com>
Date: Mon, 31 Aug 2020 16:15:42 +0800
Subject: [PATCH 21/84] Fix lv_page_glue_obj() interface for
 lv_binding_micropython. (#1759)

---
 src/lv_widgets/lv_list.c     | 2 +-
 src/lv_widgets/lv_page.c     | 3 ++-
 src/lv_widgets/lv_page.h     | 3 ++-
 src/lv_widgets/lv_tileview.c | 2 +-
 4 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/lv_widgets/lv_list.c b/src/lv_widgets/lv_list.c
index 5a1cfb144..fd8d5a41a 100644
--- a/src/lv_widgets/lv_list.c
+++ b/src/lv_widgets/lv_list.c
@@ -170,7 +170,7 @@ lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * t
     /*Set the default styles*/
     lv_theme_apply(btn, LV_THEME_LIST_BTN);
 
-    lv_page_glue_obj(btn, true);
+    lv_page_glue_obj(list, btn, true);
     lv_btn_set_layout(btn, LV_LAYOUT_ROW_MID);
 
     lv_layout_t list_layout = lv_list_get_layout(list);
diff --git a/src/lv_widgets/lv_page.c b/src/lv_widgets/lv_page.c
index f2330de78..0c81100a0 100644
--- a/src/lv_widgets/lv_page.c
+++ b/src/lv_widgets/lv_page.c
@@ -457,10 +457,11 @@ bool lv_page_on_edge(lv_obj_t * page, lv_page_edge_t edge)
 
 /**
  * Glue the object to the page. After it the page can be moved (dragged) with this object too.
+ * @param page pointer to a page object
  * @param obj pointer to an object on a page
  * @param glue true: enable glue, false: disable glue
  */
-void lv_page_glue_obj(lv_obj_t * obj, bool glue)
+void lv_page_glue_obj(lv_obj_t * page, lv_obj_t * obj, bool glue)
 {
     lv_obj_set_drag_parent(obj, glue);
     lv_obj_set_drag(obj, glue);
diff --git a/src/lv_widgets/lv_page.h b/src/lv_widgets/lv_page.h
index 051dce509..387afc6e7 100644
--- a/src/lv_widgets/lv_page.h
+++ b/src/lv_widgets/lv_page.h
@@ -378,10 +378,11 @@ bool lv_page_on_edge(lv_obj_t * page, lv_page_edge_t edge);
 
 /**
  * Glue the object to the page. After it the page can be moved (dragged) with this object too.
+ * @param page pointer to a page object
  * @param obj pointer to an object on a page
  * @param glue true: enable glue, false: disable glue
  */
-void lv_page_glue_obj(lv_obj_t * obj, bool glue);
+void lv_page_glue_obj(lv_obj_t * page, lv_obj_t * obj, bool glue);
 
 /**
  * Focus on an object. It ensures that the object will be visible on the page.
diff --git a/src/lv_widgets/lv_tileview.c b/src/lv_widgets/lv_tileview.c
index 0b471b83f..73014a7f5 100644
--- a/src/lv_widgets/lv_tileview.c
+++ b/src/lv_widgets/lv_tileview.c
@@ -156,7 +156,7 @@ void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element)
     LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
     LV_ASSERT_NULL(tileview);
 
-    lv_page_glue_obj(element, true);
+    lv_page_glue_obj(tileview, element, true);
 }
 
 /*=====================

From f09d871e4c8798fe42b79feb52b32f25bf2a2a88 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 2 Sep 2020 11:56:51 +0200
Subject: [PATCH 22/84] add lv_obj_has/set/clear_flag() instead unique function
 for click, hidden etc

---
 src/lv_core/lv_grid.c     |   4 +-
 src/lv_core/lv_group.c    |  24 +---
 src/lv_core/lv_indev.c    |  25 +---
 src/lv_core/lv_obj.c      | 257 ++++----------------------------------
 src/lv_core/lv_obj.h      | 179 ++++++--------------------
 src/lv_core/lv_refr.c     |   4 +-
 src/lv_hal/lv_hal_disp.c  |   4 +-
 src/lv_hal/lv_hal_indev.h |   7 +-
 src/lv_widgets/lv_label.c |   2 +-
 9 files changed, 83 insertions(+), 423 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 6d4b3665b..a7a08a588 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -216,7 +216,7 @@ static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     uint32_t child_cnt = lv_obj_count_children(cont);
 
-    uint32_t col_cnt = (child_cnt / grid->row_dsc_len) + 1;
+    uint32_t col_cnt = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len) + 1; /*+ grid->row_dsc_len - 1 to round up*/
     /* If `col_dsc_buf_used`, nested a call of this func. will release `col_dsc_buf_used` because it think it taken it.
      * So mark that if the buffer was taken in this call*/
     bool col_dsc_buf_mine = false;
@@ -272,7 +272,7 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     lv_grid_t * grid = cont->grid;
     uint32_t child_cnt = lv_obj_count_children(cont);
-    uint32_t row_cnt = (child_cnt / grid->col_dsc_len) + 1;
+    uint32_t row_cnt = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len) + 1; /*+ grid->col_dsc_len - 1 to round up*/
     bool row_dsc_buf_mine = false;
     /*At worst case all children is gird item prepare place for all of them*/
     lv_coord_t * rows_h;
diff --git a/src/lv_core/lv_group.c b/src/lv_core/lv_group.c
index a926a5a0c..d5567b1ab 100644
--- a/src/lv_core/lv_group.c
+++ b/src/lv_core/lv_group.c
@@ -31,7 +31,6 @@
 static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
                             void * (*move)(const lv_ll_t *, const void *));
 static void lv_group_refocus(lv_group_t * g);
-static void obj_to_foreground(lv_obj_t * obj);
 
 /**********************
  *  STATIC VARIABLES
@@ -241,9 +240,6 @@ void lv_group_focus_obj(lv_obj_t * obj)
                 lv_res_t res = lv_event_send(*g->obj_focus, LV_EVENT_FOCUSED, NULL);
                 if(res != LV_RES_OK) return;
                 lv_obj_invalidate(*g->obj_focus);
-
-                /*If the object or its parent has `top == true` bring it to the foreground*/
-                obj_to_foreground(*g->obj_focus);
             }
             break;
         }
@@ -490,7 +486,7 @@ static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
         if(obj_next == NULL) continue;
 
         /*Hidden objects don't receive focus*/
-        if(!lv_obj_get_hidden(*obj_next)) break;
+        if(lv_obj_has_flag(*obj_next, LV_OBJ_FLAG_HIDDEN) == false) break;
     }
 
     if(obj_next == group->obj_focus) return; /*There's only one visible object and it's already focused*/
@@ -508,28 +504,10 @@ static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
     lv_res_t res = lv_event_send(*group->obj_focus, LV_EVENT_FOCUSED, NULL);
     if(res != LV_RES_OK) return;
 
-    /*If the object or its parent has `top == true` bring it to the foreground*/
-    obj_to_foreground(*group->obj_focus);
-
     lv_obj_invalidate(*group->obj_focus);
 
     if(group->focus_cb) group->focus_cb(group);
 }
 
-static void obj_to_foreground(lv_obj_t * obj)
-{
-    /*Search for 'top' attribute*/
-    lv_obj_t * i        = obj;
-    lv_obj_t * last_top = NULL;
-    while(i != NULL) {
-        if(i->top != 0) last_top = i;
-        i = lv_obj_get_parent(i);
-    }
-
-    if(last_top != NULL) {
-        /*Move the last_top object to the foreground*/
-        lv_obj_move_foreground(last_top);
-    }
-}
 
 #endif /*LV_USE_GROUP != 0*/
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index e820fe127..3a258729d 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -212,7 +212,7 @@ void lv_indev_set_cursor(lv_indev_t * indev, lv_obj_t * cur_obj)
     indev->cursor = cur_obj;
     lv_obj_set_parent(indev->cursor, lv_disp_get_layer_sys(indev->driver.disp));
     lv_obj_set_pos(indev->cursor, indev->proc.types.pointer.act_point.x, indev->proc.types.pointer.act_point.y);
-    lv_obj_set_click(indev->cursor, false);
+    lv_obj_add_flag(indev->cursor, LV_OBJ_FLAG_CLICKABLE);
 }
 
 #if LV_USE_GROUP
@@ -831,7 +831,7 @@ static void indev_proc_press(lv_indev_proc_t * proc)
     }
     /*If there is last object but it is not scrolled and not protected also search*/
     else if(proc->types.pointer.scroll_obj == NULL &&
-            lv_obj_is_protected(indev_obj_act, LV_PROTECT_PRESS_LOST) == false) {
+            lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_PRESS_LOCK) == false) {
         indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_sys(disp), &proc->types.pointer.act_point);
         if(indev_obj_act == NULL) indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_top(disp),
                                                                           &proc->types.pointer.act_point);
@@ -884,19 +884,6 @@ static void indev_proc_press(lv_indev_proc_t * proc)
             proc->types.pointer.vect.x         = 0;
             proc->types.pointer.vect.y         = 0;
 
-            /*Search for 'top' attribute*/
-            lv_obj_t * i        = indev_obj_act;
-            lv_obj_t * last_top = NULL;
-            while(i != NULL) {
-                if(i->top) last_top = i;
-                i = lv_obj_get_parent(i);
-            }
-
-            if(last_top != NULL) {
-                /*Move the last_top object to the foreground*/
-                lv_obj_move_foreground(last_top);
-            }
-
             /*Send a signal about the press*/
             lv_signal_send(indev_obj_act, LV_SIGNAL_PRESSED, indev_act);
             if(indev_reset_check(proc)) return;
@@ -1079,10 +1066,10 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
 
         /*If then the children was not ok, and this obj is clickable
          * and it or its parent is not hidden then save this object*/
-        if(found_p == NULL && lv_obj_get_click(obj) != false) {
+        if(found_p == NULL && lv_obj_has_flag(obj, LV_OBJ_FLAG_CLICKABLE)) {
             lv_obj_t * hidden_i = obj;
             while(hidden_i != NULL) {
-                if(lv_obj_get_hidden(hidden_i) == true) break;
+                if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN) == true) break;
                 hidden_i = lv_obj_get_parent(hidden_i);
             }
             /*No parent found with hidden == true*/
@@ -1101,7 +1088,7 @@ static void indev_click_focus(lv_indev_proc_t * proc)
 {
     /*Handle click focus*/
     lv_obj_t * obj_to_focus = lv_obj_get_focused_obj(indev_obj_act);
-    if(lv_obj_is_protected(indev_obj_act, LV_PROTECT_CLICK_FOCUS) == false &&
+    if(lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_PRESS_LOCK) == false &&
        proc->types.pointer.last_pressed != obj_to_focus) {
 #if LV_USE_GROUP
         lv_group_t * g_act = lv_obj_get_group(indev_obj_act);
@@ -1362,7 +1349,7 @@ static void indev_gesture(lv_indev_proc_t * proc)
     lv_obj_t * gesture_obj = proc->types.pointer.act_obj;
 
     /*If gesture parent is active check recursively the gesture attribute*/
-    while(gesture_obj && lv_obj_get_gesture_parent(gesture_obj)) {
+    while(gesture_obj && lv_obj_has_flag(gesture_obj, LV_OBJ_FLAG_GESTURE_BUBBLE)) {
         gesture_obj = lv_obj_get_parent(gesture_obj);
     }
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 193d977dd..f314a9c9e 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -329,14 +329,9 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
     /*Set attributes*/
     new_obj->adv_hittest  = 0;
-    new_obj->click        = 1;
     new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
-    new_obj->hidden       = 0;
-    new_obj->top          = 0;
-    new_obj->protect      = LV_PROTECT_NONE;
-    new_obj->parent_event = 0;
-    new_obj->gesture_parent = parent ? 1 : 0;
-    new_obj->focus_parent  = 0;
+    new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
+    if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
     new_obj->scroll.x = 0;
     new_obj->scroll.y = 0;
@@ -374,14 +369,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
         /*Copy attributes*/
         new_obj->adv_hittest  = copy->adv_hittest;
-        new_obj->click        = copy->click;
+        new_obj->flags        = copy->flags;
         new_obj->scroll_mode  = copy->scroll_mode;
-        new_obj->hidden       = copy->hidden;
-        new_obj->top          = copy->top;
-        new_obj->parent_event = copy->parent_event;
-
-        new_obj->protect      = copy->protect;
-        new_obj->gesture_parent = copy->gesture_parent;
 
 #if LV_USE_GROUP
         /*Add to the same group*/
@@ -533,7 +522,7 @@ void lv_obj_invalidate(const lv_obj_t * obj)
  */
 bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
 {
-    if(lv_obj_get_hidden(obj)) return false;
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return false;
 
     /*Invalidate the object only if it belongs to the curent or previous'*/
     lv_obj_t * obj_scr = lv_obj_get_screen(obj);
@@ -562,7 +551,7 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
         while(par != NULL) {
             is_common = _lv_area_intersect(area, area, &par->coords);
             if(is_common == false) return false;       /*If no common parts with parent break;*/
-            if(lv_obj_get_hidden(par)) return false; /*If the parent is hidden then the child is hidden and won't be drawn*/
+            if(lv_obj_has_flag(par, LV_OBJ_FLAG_HIDDEN)) return false; /*If the parent is hidden then the child is hidden and won't be drawn*/
 
             par = lv_obj_get_parent(par);
         }
@@ -794,12 +783,6 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     lv_obj_t * par = lv_obj_get_parent(obj);
     if(par != NULL) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
 
-    /*Tell the children the parent's size has changed*/
-    lv_obj_t * i;
-    _LV_LL_READ(obj->child_ll, i) {
-        i->signal_cb(i, LV_SIGNAL_PARENT_SIZE_CHG,  &ori);
-    }
-
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
     return true;
@@ -1763,25 +1746,6 @@ void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
  * Attribute set
  *----------------*/
 
-/**
- * Hide an object. It won't be visible and clickable.
- * @param obj pointer to an object
- * @param en true: hide the object
- */
-void lv_obj_set_hidden(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(!obj->hidden) lv_obj_invalidate(obj); /*Invalidate when not hidden (hidden objects are ignored) */
-
-    obj->hidden = en == false ? 0 : 1;
-
-    if(!obj->hidden) lv_obj_invalidate(obj); /*Invalidate when not hidden (hidden objects are ignored) */
-
-    lv_obj_t * par = lv_obj_get_parent(obj);
-    if(par) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
-}
-
 /**
  * Set whether advanced hit-testing is enabled on an object
  * @param obj pointer to an object
@@ -1794,31 +1758,6 @@ void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en)
     obj->adv_hittest = en == false ? 0 : 1;
 }
 
-/**
- * Enable or disable the clicking of an object
- * @param obj pointer to an object
- * @param en true: make the object clickable
- */
-void lv_obj_set_click(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->click = (en == true ? 1 : 0);
-}
-
-/**
- * Enable to bring this object to the foreground if it
- * or any of its children is clicked
- * @param obj pointer to an object
- * @param en true: enable the auto top feature
- */
-void lv_obj_set_top(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->top = (en == true ? 1 : 0);
-}
-
 /**
  * Set how the scrollbars should behave.
  * @param obj pointer to an object
@@ -1833,54 +1772,6 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
     lv_obj_invalidate(obj);
 }
 
-/**
-* Enable to use parent for gesture related operations.
-* If trying to gesture the object the parent will be moved instead
-* @param obj pointer to an object
-* @param en true: enable the 'gesture parent' for the object
-*/
-void lv_obj_set_gesture_parent(lv_obj_t * obj, bool en)
-{
-    obj->gesture_parent = (en == true ? 1 : 0);
-}
-
-/**
-* Enable to use parent for focus state.
-* When object is focused the parent will get the state instead (visual only)
-* @param obj pointer to an object
-* @param en true: enable the 'focus parent' for the object
-*/
-void lv_obj_set_focus_parent(lv_obj_t * obj, bool en)
-{
-    if(lv_obj_is_focused(obj)) {
-        if(en) {
-            obj->focus_parent = 1;
-            lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
-            lv_obj_set_state(lv_obj_get_focused_obj(obj), LV_STATE_FOCUSED);
-        }
-        else {
-            lv_obj_clear_state(lv_obj_get_focused_obj(obj), LV_STATE_FOCUSED | LV_STATE_EDITED);
-            lv_obj_set_state(obj, LV_STATE_FOCUSED);
-            obj->focus_parent = 0;
-        }
-    }
-    else {
-        obj->focus_parent = (en == true ? 1 : 0);
-    }
-}
-
-/**
- * Propagate the events to the parent too
- * @param obj pointer to an object
- * @param en true: enable the event propagation
- */
-void lv_obj_set_parent_event(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->parent_event = (en == true ? 1 : 0);
-}
-
 /**
  * Set the base direction of the object
  * @param obj pointer to an object
@@ -1903,31 +1794,24 @@ void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir)
     base_dir_refr_children(obj);
 }
 
-/**
- * Set a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from `lv_protect_t`
- */
-void lv_obj_add_protect(lv_obj_t * obj, uint8_t prot)
+
+void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    obj->protect |= prot;
+    obj->flags |= f;
 }
 
-/**
- * Clear a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from `lv_protect_t`
- */
-void lv_obj_clear_protect(lv_obj_t * obj, uint8_t prot)
+
+
+void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    prot = (~prot) & 0xFF;
-    obj->protect &= prot;
+    obj->flags &= (~f);
 }
 
+
 /**
  * Set the state (fully overwrite) of an object.
  * If specified in the styles a transition animation will be started
@@ -2001,6 +1885,7 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
 
 }
 
+
 /**
  * Add a given state or states to the object. The other state bits will remain unchanged.
  * If specified in the styles a transition animation will be started
@@ -2185,7 +2070,7 @@ lv_res_t lv_event_send_func(lv_event_cb_t event_xcb, lv_obj_t * obj, lv_event_t
     }
 
     if(obj) {
-        if(obj->parent_event && obj->parent) {
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_EVENT_BUBBLE) && obj->parent) {
             lv_res_t res = lv_event_send(obj->parent, event, data);
             if(res != LV_RES_OK) {
                 return LV_RES_INV;
@@ -3124,16 +3009,11 @@ lv_style_t * lv_obj_get_local_style(lv_obj_t * obj, uint8_t part)
  * Attribute get
  *----------------*/
 
-/**
- * Get the hidden attribute of an object
- * @param obj pointer to an object
- * @return true: the object is hidden
- */
-bool lv_obj_get_hidden(const lv_obj_t * obj)
+bool lv_obj_has_flag(lv_obj_t * obj, lv_obj_flag_t f)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return obj->hidden == 0 ? false : true;
+    return obj->flags & f ? true : false;
 }
 
 /**
@@ -3148,29 +3028,6 @@ bool lv_obj_get_adv_hittest(const lv_obj_t * obj)
     return obj->adv_hittest == 0 ? false : true;
 }
 
-/**
- * Get the click enable attribute of an object
- * @param obj pointer to an object
- * @return true: the object is clickable
- */
-bool lv_obj_get_click(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->click == 0 ? false : true;
-}
-
-/**
- * Get the top enable attribute of an object
- * @param obj pointer to an object
- * @return true: the auto top feature is enabled
- */
-bool lv_obj_get_top(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->top == 0 ? false : true;
-}
 
 /**
  * Get how the scrollbars should behave.
@@ -3184,39 +3041,6 @@ lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
     return obj->scroll_mode;
 }
 
-/**
-* Get the gesture parent attribute of an object
-* @param obj pointer to an object
-* @return true: gesture parent is enabled
-*/
-bool lv_obj_get_gesture_parent(const lv_obj_t * obj)
-{
-    return obj->gesture_parent == 0 ? false : true;
-}
-
-/**
-* Get the focus parent attribute of an object
-* @param obj pointer to an object
-* @return true: focus parent is enabled
-*/
-bool lv_obj_get_focus_parent(const lv_obj_t * obj)
-{
-    return obj->focus_parent == 0 ? false : true;
-}
-
-/**
- * Get the parent event attribute of an object
- * @param obj pointer to an object
- * @return true: parent event is enabled
- */
-bool lv_obj_get_parent_event(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->parent_event == 0 ? false : true;
-}
-
-
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@@ -3237,31 +3061,6 @@ lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 #endif
 }
 
-/**
- * Get the protect field of an object
- * @param obj pointer to an object
- * @return protect field ('OR'ed values of `lv_protect_t`)
- */
-uint8_t lv_obj_get_protect(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->protect;
-}
-
-/**
- * Check at least one bit of a given protect bitfield is set
- * @param obj pointer to an object
- * @param prot protect bits to test ('OR'ed values of `lv_protect_t`)
- * @return false: none of the given bits are set, true: at least one bit is set
- */
-bool lv_obj_is_protected(const lv_obj_t * obj, uint8_t prot)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return (obj->protect & prot) == 0 ? false : true;
-}
-
 lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@@ -4159,7 +3958,7 @@ lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
 {
     if(obj == NULL) return NULL;
     const lv_obj_t * focus_obj = obj;
-    while(lv_obj_get_focus_parent(focus_obj) != false && focus_obj != NULL) {
+    while(lv_obj_has_flag(focus_obj, LV_OBJ_FLAG_FOCUS_BUBBLE) != false && focus_obj != NULL) {
         focus_obj = lv_obj_get_parent(focus_obj);
     }
 
@@ -4193,9 +3992,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
     }
     else 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;
-
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
@@ -4208,11 +4004,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
                 lv_grid_full_refr(obj);
             }
         }
-
-//        else if(lv_obj_is_content_sensitive(obj)) {
-//                lv_grid_full_refr(lv_obj_get_parent(obj));
-//        }
-
     }
     else if(sign == LV_SIGNAL_SCROLL) {
 
@@ -4252,11 +4043,13 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
-        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-        while(child) {
-            lv_obj_set_pos(child, child->x_set, child->y_set);
-            child = lv_obj_get_child(obj, child);
-        }
+        if(lv_obj_is_grid_item(obj)) lv_grid_full_refr(obj);
+
+//        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+//        while(child) {
+//            lv_obj_set_pos(child, child->x_set, child->y_set);
+//            child = lv_obj_get_child(obj, child);
+//        }
 
 
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index cbfd9aef3..0ad5e0593 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -126,7 +126,6 @@ enum {
     LV_SIGNAL_CLEANUP, /**< Object is being deleted */
     LV_SIGNAL_CHILD_CHG, /**< Child was removed/added */
     LV_SIGNAL_COORD_CHG, /**< Object coordinates/size have changed */
-    LV_SIGNAL_PARENT_SIZE_CHG, /**< Parent's size has changed */
     LV_SIGNAL_STYLE_CHG,    /**< Object's style has changed */
     LV_SIGNAL_BASE_DIR_CHG, /**<The base dir has changed*/
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
@@ -159,19 +158,6 @@ typedef uint8_t lv_signal_t;
 
 typedef lv_res_t (*lv_signal_cb_t)(struct _lv_obj_t * obj, lv_signal_t sign, void * param);
 
-/*Protect some attributes (max. 8 bit)*/
-enum {
-    LV_PROTECT_NONE      = 0x00,
-    LV_PROTECT_CHILD_CHG = 0x01,   /**< Disable the child change signal. Used by the library*/
-    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,  /**< If the `indev` was pressing this object but swiped out while
-                                      pressing do not search other object.*/
-    LV_PROTECT_CLICK_FOCUS = 0x20, /**< Prevent focusing the object by clicking on it*/
-};
-typedef uint8_t lv_protect_t;
 
 enum {
     LV_STATE_DEFAULT   =  0x00,
@@ -185,6 +171,35 @@ enum {
 
 typedef uint8_t lv_state_t;
 
+enum {
+    LV_SCROLL_SNAP_OFF,
+    LV_SCROLL_SNAP_NORMAL,
+    LV_SCROLL_SNAP_ALWAYS,
+};
+
+typedef uint8_t lv_scroll_snap_t;
+
+enum {
+    LV_SCROLL_SNAP_ALIGN_START,
+    LV_SCROLL_SNAP_ALIGN_END,
+    LV_SCROLL_SNAP_ALIGN_CENTER
+};
+typedef uint8_t lv_scroll_snap_align_t;
+
+
+enum {
+    LV_OBJ_FLAG_HIDDEN,
+    LV_OBJ_FLAG_CLICKABLE,
+    LV_OBJ_FLAG_SCROLLABLE,
+    LV_OBJ_FLAG_SCROLL_ELASTIC,
+    LV_OBJ_FLAG_SCROLL_MOMENTUM,
+    LV_OBJ_FLAG_PRESS_LOCK,
+    LV_OBJ_FLAG_EVENT_BUBBLE,
+    LV_OBJ_FLAG_GESTURE_BUBBLE,
+    LV_OBJ_FLAG_FOCUS_BUBBLE,
+};
+typedef uint16_t lv_obj_flag_t;
+
 /** Scrollbar modes: shows when should the scrollbars be visible*/
 enum {
     LV_SCROLL_MODE_OFF    = 0x0, /**< Never show scroll bars*/
@@ -218,15 +233,16 @@ typedef struct _lv_obj_t {
     lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 
     /*Attributes and states*/
-    uint8_t click           : 1; /**< 1: Can be pressed by an input device*/
-    uint8_t hidden          : 1; /**< 1: Object is hidden*/
-    uint8_t top             : 1; /**< 1: If the object or its children is clicked it goes to the foreground*/
-    uint8_t parent_event    : 1; /**< 1: Send the object's events to the parent too. */
-    uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
-    uint8_t gesture_parent  : 1; /**< 1: Parent will be gesture instead*/
-    uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
+    lv_obj_flag_t flags     : 9;
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
+    lv_scroll_snap_t snap_x : 2;
+    lv_scroll_snap_t snap_y : 2;
+    lv_scroll_snap_align_t snap_align_x : 2;
+    lv_scroll_snap_align_t snap_align_y : 2;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
+    uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
+    lv_state_t state;
+
     lv_coord_t x_set;
     lv_coord_t y_set;
     lv_coord_t w_set;
@@ -236,9 +252,6 @@ typedef struct _lv_obj_t {
     void * group_p;
 #endif
 
-    uint8_t protect;            /**< Automatically happening actions can be prevented.
-                                     'OR'ed values from `lv_protect_t`*/
-    lv_state_t state;
 
 #if LV_USE_USER_DATA
     lv_obj_user_data_t user_data; /**< Custom user data for object. */
@@ -711,13 +724,6 @@ void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
  * Attribute set
  *----------------*/
 
-/**
- * Hide an object. It won't be visible and clickable.
- * @param obj pointer to an object
- * @param en true: hide the object
- */
-void lv_obj_set_hidden(lv_obj_t * obj, bool en);
-
 /**
  * Set whether advanced hit-testing is enabled on an object
  * @param obj pointer to an object
@@ -725,28 +731,6 @@ void lv_obj_set_hidden(lv_obj_t * obj, bool en);
  */
 void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en);
 
-/**
- * Enable or disable the clicking of an object
- * @param obj pointer to an object
- * @param en true: make the object clickable
- */
-void lv_obj_set_click(lv_obj_t * obj, bool en);
-
-/**
- * Enable to bring this object to the foreground if it
- * or any of its children is clicked
- * @param obj pointer to an object
- * @param en true: enable the auto top feature
- */
-void lv_obj_set_top(lv_obj_t * obj, bool en);
-
-/**
-* Enable to use parent for focus state.
-* When object is focused the parent will get the state instead (visual only)
-* @param obj pointer to an object
-* @param en true: enable the 'focus parent' for the object
-*/
-void lv_obj_set_focus_parent(lv_obj_t * obj, bool en);
 
 /**
  * Set how the scrollbars should behave.
@@ -755,21 +739,6 @@ void lv_obj_set_focus_parent(lv_obj_t * obj, bool en);
  */
 void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode);
 
-/**
-* Enable to use parent for gesture related operations.
-* If trying to gesture the object the parent will be moved instead
-* @param obj pointer to an object
-* @param en true: enable the 'gesture parent' for the object
-*/
-void lv_obj_set_gesture_parent(lv_obj_t * obj, bool en);
-
-/**
- * Propagate the events to the parent too
- * @param obj pointer to an object
- * @param en true: enable the event propagation
- */
-void lv_obj_set_parent_event(lv_obj_t * obj, bool en);
-
 /**
  * Set the base direction of the object
  * @param obj pointer to an object
@@ -777,19 +746,8 @@ void lv_obj_set_parent_event(lv_obj_t * obj, bool en);
  */
 void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir);
 
-/**
- * Set a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from `lv_protect_t`
- */
-void lv_obj_add_protect(lv_obj_t * obj, uint8_t prot);
-
-/**
- * Clear a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from `lv_protect_t`
- */
-void lv_obj_clear_protect(lv_obj_t * obj, uint8_t prot);
+void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f);
+void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f);
 
 /**
  * Set the state (fully overwrite) of an object.
@@ -1208,12 +1166,8 @@ lv_style_t * lv_obj_get_local_style(lv_obj_t * obj, uint8_t part);
  * Attribute get
  *----------------*/
 
-/**
- * Get the hidden attribute of an object
- * @param obj pointer to an object
- * @return true: the object is hidden
- */
-bool lv_obj_get_hidden(const lv_obj_t * obj);
+
+bool lv_obj_has_flag(lv_obj_t * obj, lv_obj_flag_t f);
 
 /**
  * Get whether advanced hit-testing is enabled on an object
@@ -1222,59 +1176,8 @@ bool lv_obj_get_hidden(const lv_obj_t * obj);
  */
 bool lv_obj_get_adv_hittest(const lv_obj_t * obj);
 
-/**
- * Get the click enable attribute of an object
- * @param obj pointer to an object
- * @return true: the object is clickable
- */
-bool lv_obj_get_click(const lv_obj_t * obj);
-
-/**
- * Get the top enable attribute of an object
- * @param obj pointer to an object
- * @return true: the auto top feature is enabled
- */
-bool lv_obj_get_top(const lv_obj_t * obj);
-
-/**
-* Get the focus parent attribute of an object
-* @param obj pointer to an object
-* @return true: focus parent is enabled
-*/
-bool lv_obj_get_focus_parent(const lv_obj_t * obj);
-
-/**
- * Get the parent event attribute of an object
- * @param obj pointer to an object
- * @return true: parent event is enabled
- */
-bool lv_obj_get_parent_event(const lv_obj_t * obj);
-
-/**
-* Get the gesture parent attribute of an object
-* @param obj pointer to an object
-* @return true: gesture parent is enabled
-*/
-bool lv_obj_get_gesture_parent(const lv_obj_t * obj);
-
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj);
 
-/**
- * Get the protect field of an object
- * @param obj pointer to an object
- * @return protect field ('OR'ed values of `lv_protect_t`)
- */
-uint8_t lv_obj_get_protect(const lv_obj_t * obj);
-
-/**
- * Check at least one bit of a given protect bitfield is set
- * @param obj pointer to an object
- * @param prot protect bits to test ('OR'ed values of `lv_protect_t`)
- * @return false: none of the given bits are set, true: at least one bit is set
- */
-bool lv_obj_is_protected(const lv_obj_t * obj, uint8_t prot);
-
-
 lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part);
 
 /**
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index cde758fa2..15079291c 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -571,7 +571,7 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
     lv_obj_t * found_p = NULL;
 
     /*If this object is fully cover the draw area check the children too */
-    if(_lv_area_is_in(area_p, &obj->coords, 0) && obj->hidden == 0) {
+    if(_lv_area_is_in(area_p, &obj->coords, 0) && (obj->flags & LV_OBJ_FLAG_HIDDEN) == 0) {
         lv_design_res_t design_res = obj->design_cb ? obj->design_cb(obj, area_p,
                                                                      LV_DESIGN_COVER_CHK) : LV_DESIGN_RES_NOT_COVER;
         if(design_res == LV_DESIGN_RES_MASKED) return NULL;
@@ -649,7 +649,7 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
 static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
 {
     /*Do not refresh hidden objects*/
-    if(obj->hidden != 0) return;
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return;
 
     bool union_ok; /* Store the return value of area_union */
     /* Truncate the original mask to the coordinates of the parent
diff --git a/src/lv_hal/lv_hal_disp.c b/src/lv_hal/lv_hal_disp.c
index ed5fbc90c..3e7a33c67 100644
--- a/src/lv_hal/lv_hal_disp.c
+++ b/src/lv_hal/lv_hal_disp.c
@@ -158,8 +158,8 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
     disp->sys_layer = lv_obj_create(NULL, NULL); /*Create sys layer on the display*/
     lv_obj_reset_style_list(disp->top_layer, LV_OBJ_PART_MAIN);
     lv_obj_reset_style_list(disp->sys_layer, LV_OBJ_PART_MAIN);
-    lv_obj_set_click(disp->top_layer, false);
-    lv_obj_set_click(disp->sys_layer, false);
+    lv_obj_clear_flag(disp->top_layer, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_clear_flag(disp->sys_layer, LV_OBJ_FLAG_CLICKABLE);
 
     lv_obj_set_scroll_mode(disp->top_layer, LV_SCROLL_MODE_OFF);
     lv_obj_set_scroll_mode(disp->sys_layer, LV_SCROLL_MODE_OFF);
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index b49080db3..1b3ab3dc6 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -50,11 +50,10 @@ typedef uint8_t lv_indev_type_t;
 enum { LV_INDEV_STATE_REL = 0, LV_INDEV_STATE_PR };
 typedef uint8_t lv_indev_state_t;
 
-
 enum {
-    LV_SCROLL_DIR_NONE = 0x0, /**< Object can't be dragged to any directions. */
-    LV_SCROLL_DIR_HOR = 0x1, /**< Object can be dragged horizontally. */
-    LV_SCROLL_DIR_VER = 0x2, /**< Object can be dragged vertically. */
+    LV_SCROLL_DIR_NONE,
+    LV_SCROLL_DIR_HOR,
+    LV_SCROLL_DIR_VER,
 };
 
 typedef uint8_t lv_scroll_dir_t;
diff --git a/src/lv_widgets/lv_label.c b/src/lv_widgets/lv_label.c
index 65e6397f6..f06595269 100644
--- a/src/lv_widgets/lv_label.c
+++ b/src/lv_widgets/lv_label.c
@@ -127,7 +127,7 @@ lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy)
     /*Init the new label*/
     if(copy == NULL) {
         lv_theme_apply(new_label, LV_THEME_LABEL);
-        lv_obj_set_click(new_label, false);
+        lv_obj_clear_flag(new_label, LV_OBJ_FLAG_CLICKABLE);
         lv_label_set_long_mode(new_label, LV_LABEL_LONG_EXPAND);
         lv_label_set_text(new_label, "Text");
     }

From 9f2526a73c3a7951b9a5b44fb8c59bbc1ca32cd6 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sat, 5 Sep 2020 11:57:17 +0200
Subject: [PATCH 23/84] implement scroll snapping

---
 src/lv_core/lv_indev.c    | 323 +++++++++++++++++++++++++++++++++-----
 src/lv_core/lv_obj.c      |  50 ++----
 src/lv_core/lv_obj.h      |  57 +++----
 src/lv_hal/lv_hal_indev.h |   1 +
 4 files changed, 324 insertions(+), 107 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 3a258729d..c48d808fa 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1175,6 +1175,116 @@ static void indev_click_focus(lv_indev_proc_t * proc)
 
 }
 
+
+static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
+{
+    if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+
+    lv_coord_t dist = LV_COORD_MAX;
+
+    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
+    while(child) {
+        lv_coord_t x_child = 0;
+        lv_coord_t x_parent = 0;
+        switch(obj->snap_align_x) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            x_child = child->coords.x1;
+            x_parent = obj->coords.x1;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            x_child = child->coords.x2;
+            x_parent = obj->coords.x2;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER:
+            x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
+            x_parent = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+        }
+
+        x_child += ofs;
+        if(x_child >= min && x_child <= max) {
+            lv_coord_t x = x_child -  x_parent;
+            if(LV_MATH_ABS(x) < LV_MATH_ABS(dist)) dist = x;
+        }
+
+        child = lv_obj_get_child_back(obj, child);
+    }
+
+    return dist == LV_COORD_MAX ? 0: -dist;
+}
+
+/**
+ * Search for snap point in the `min` - `max` range.
+ * @param obj the object on which snap point should be found
+ * @param min ignore snap points smaller then this. (Absolute coordinate)
+ * @param max ignore snap points greater then this. (Absolute coordinate)
+ * @param ofs offset to snap points. Useful the get a snap point in an imagined case
+ *            what if children are already moved by this value
+ * @return the distance of the snap point.
+ */
+static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
+{
+    if(obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+
+    lv_coord_t dist = LV_COORD_MAX;
+
+    uint32_t cc = 0;
+    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
+    while(child) {
+        cc++;
+        lv_coord_t y_child = 0;
+        lv_coord_t y_parent = 0;
+        switch(obj->snap_align_y) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            y_child = child->coords.y1;
+            y_parent = obj->coords.y1;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            y_child = child->coords.y2;
+            y_parent = obj->coords.y2;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER:
+            y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
+            y_parent = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+        }
+
+        y_child += ofs;
+        if(y_child >= min && y_child <= max) {
+            lv_coord_t y = y_child -  y_parent;
+            if(LV_MATH_ABS(y) < LV_MATH_ABS(dist)) dist = y;
+        }
+
+        child = lv_obj_get_child_back(obj, child);
+    }
+
+    printf("child cnt: %d\n", cc);
+
+    return dist == LV_COORD_MAX ? 0 : -dist;
+}
+
+static void scroll_limit(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y)
+{
+    if(diff_y) {
+        if(proc->types.pointer.scroll_sum.y + *diff_y < proc->types.pointer.scroll_area.y1) {
+           *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
+        }
+
+        if(proc->types.pointer.scroll_sum.y + *diff_y > proc->types.pointer.scroll_area.y2) {
+            *diff_y = proc->types.pointer.scroll_area.y2 - proc->types.pointer.scroll_sum.y;
+        }
+    }
+
+    if(diff_x) {
+        if(proc->types.pointer.scroll_sum.x + *diff_x < proc->types.pointer.scroll_area.x1) {
+            *diff_x = proc->types.pointer.scroll_area.x1 - proc->types.pointer.scroll_sum.x;
+        }
+
+        if(proc->types.pointer.scroll_sum.x + *diff_x > proc->types.pointer.scroll_area.x2) {
+            *diff_x = proc->types.pointer.scroll_area.x2 - proc->types.pointer.scroll_sum.x;
+        }
+    }
+}
+
+
 /**
  * Handle the scrolling
  * @param indev pointer to a input device state
@@ -1242,22 +1352,73 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
                (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit))
             {
                 proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
-
-                if(!hor_en)  proc->types.pointer.scroll_sum.x = 0;
-                if(!ver_en)  proc->types.pointer.scroll_sum.y = 0;
-
-                break;  /*It"s good scrollable object, use it*/
+                break;  /*It's good scrollable object, use it*/
             }
             proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
         }
-    }
 
-    if(proc->types.pointer.scroll_obj == NULL) {
-        if(scroll_candidate_obj) {
-            proc->types.pointer.scroll_dir = dirs_candidate;
-            proc->types.pointer.scroll_obj = scroll_candidate_obj;
-        } else {
-            return;
+        /*Use the last candidate*/
+        if(proc->types.pointer.scroll_obj == NULL) {
+            if(scroll_candidate_obj) {
+                proc->types.pointer.scroll_dir = dirs_candidate;
+                proc->types.pointer.scroll_obj = scroll_candidate_obj;
+            } else {
+                return;
+            }
+        }
+
+        proc->types.pointer.scroll_sum.x = 0;
+        proc->types.pointer.scroll_sum.y = 0;
+
+        lv_obj_t * obj = proc->types.pointer.scroll_obj;
+        /*If there no STOP allow scrolling anywhere*/
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_STOP) == false) {
+            lv_area_set(&proc->types.pointer.scroll_area, LV_COORD_MIN, LV_COORD_MIN, LV_COORD_MAX, LV_COORD_MAX);
+        }
+        /*With STOP limit the scrolling to the perv and next snap point*/
+        else {
+            switch(obj->snap_align_y) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
+                printf("%d, %d\n", proc->types.pointer.scroll_area.y1, proc->types.pointer.scroll_area.y2);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER: {
+                lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
+                break;
+            }
+            default:
+                proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
+                break;
+            }
+
+            switch(obj->snap_align_x) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER: {
+                lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
+                break;
+            }
+            default:
+                proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
+                break;
+            }
         }
     }
 
@@ -1279,10 +1440,39 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
             if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
             if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
         }
+
+        /*Respect the scroll limit area*/
+        scroll_limit(proc, &diff_x, &diff_y);
+
         lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
+        proc->types.pointer.scroll_sum.x += diff_x;
+        proc->types.pointer.scroll_sum.y += diff_y;
     }
 }
 
+static lv_coord_t scroll_throw_predict_y(lv_indev_proc_t * proc)
+{
+    lv_coord_t y =  proc->types.pointer.scroll_throw_vect.y;
+    lv_coord_t move = 0;
+    while(y) {
+        move += y;
+        y = y * (100 - indev_act->driver.scroll_throw) / 100;
+    }
+    return move;
+}
+
+
+static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc)
+{
+    lv_coord_t x =  proc->types.pointer.scroll_throw_vect.x;
+    lv_coord_t move = 0;
+    while(x) {
+        move += x;
+        x = x * (100 - indev_act->driver.scroll_throw) / 100;
+    }
+    return move;
+}
+
 /**
  * Handle throwing by after scrolling
  * @param indev pointer to an input device state
@@ -1292,41 +1482,94 @@ static void indev_scroll_throw_handler(lv_indev_proc_t * proc)
     lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
 
     if(scroll_obj == NULL) return;
-    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) return;
+    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) {
+        return;
+    }
+    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
+        proc->types.pointer.scroll_throw_vect.x = 0;
+        /*If no snapping "throw"*/
+        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+            proc->types.pointer.scroll_throw_vect.y =
+                    proc->types.pointer.scroll_throw_vect.y * (100 - indev_act->driver.scroll_throw) / 100;
 
-    /*Reduce the vectors*/
-    proc->types.pointer.scroll_throw_vect.x =
-        proc->types.pointer.scroll_throw_vect.x * (100 - indev_act->driver.scroll_throw) / 100;
-    proc->types.pointer.scroll_throw_vect.y =
-        proc->types.pointer.scroll_throw_vect.y * (100 - indev_act->driver.scroll_throw) / 100;
-
-    switch(proc->types.pointer.scroll_dir) {
-        case LV_SCROLL_DIR_HOR:
-        {
-            proc->types.pointer.scroll_throw_vect.y = 0;
-            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
-            /*If scrolled inside reduce faster*/
-            if(sl < 0 || sr < 0) proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
-            break;
-        }
-        case LV_SCROLL_DIR_VER:
-        {
-            proc->types.pointer.scroll_throw_vect.x = 0;
             lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+
             /*If scrolled inside reduce faster*/
-            if(st < 0 || sb < 0) proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
-            break;
+            if(st < 0 || sb < 0) {
+                proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
+            }
+
+            lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
+        }
+        /*With snapping find the nearest snap point and scroll there*/
+        else {
+            lv_coord_t diff_y = scroll_throw_predict_y(proc);
+            proc->types.pointer.scroll_throw_vect.y = 0;
+            scroll_limit(proc, NULL, &diff_y);
+            lv_coord_t y = find_snap_point_y(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_y);
+            lv_obj_scroll_by(scroll_obj, 0, diff_y + y, LV_ANIM_ON);
+        }
+    }
+    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
+        proc->types.pointer.scroll_throw_vect.y = 0;
+        /*If no snapping "throw"*/
+        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+            proc->types.pointer.scroll_throw_vect.x =
+                    proc->types.pointer.scroll_throw_vect.x * (100 - indev_act->driver.scroll_throw) / 100;
+
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
+
+            /*If scrolled inside reduce faster*/
+            if(sl < 0 || sr < 0) {
+                proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
+            }
+
+            lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
+        }
+        /*With snapping find the nearest snap point and scroll there*/
+        else {
+            lv_coord_t diff_x = scroll_throw_predict_x(proc);
+            proc->types.pointer.scroll_throw_vect.x = 0;
+            scroll_limit(proc, NULL, &diff_x);
+            lv_coord_t x = find_snap_point_x(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_x);
+            lv_obj_scroll_by(scroll_obj, x + diff_x, 0, LV_ANIM_ON);
         }
     }
 
-    if((proc->types.pointer.scroll_throw_vect.x != 0 || proc->types.pointer.scroll_throw_vect.y != 0)) {
-        lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, proc->types.pointer.scroll_throw_vect.y);
-    }
-    /*If the vectors become 0 then finish scrolling
-       signal*/
-    else {
+
+    /*Check if the scroll has finished */
+    if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
+        /*Revert if scrolled in*/
+        /*If vertically scrollable and not controlled by snap*/
+        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+            if(st > 0 || sb > 0) {
+                if(st < 0) {
+                    lv_obj_scroll_by(scroll_obj, 0, st, LV_ANIM_ON);
+                }
+                else if(sb < 0) {
+                    lv_obj_scroll_by(scroll_obj, 0, -sb, LV_ANIM_ON);
+                }
+            }
+        }
+
+        /*If horizontally scrollable and not controlled by snap*/
+        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
+            if (sl > 0 || sr > 0) {
+                if(sl < 0) {
+                    lv_obj_scroll_by(scroll_obj, sl, 0, LV_ANIM_ON);
+                }
+                else if(sr < 0) {
+                    lv_obj_scroll_by(scroll_obj, -sr, 0, LV_ANIM_ON);
+                }
+            }
+        }
+
         proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
         proc->types.pointer.scroll_obj = NULL;
         lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_END, indev_act);
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index f314a9c9e..2e7e05584 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1241,7 +1241,8 @@ void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->scroll.y += y;
 
     refresh_children_position(obj, x, y);
-    lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
+    lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
+    if(res != LV_RES_OK) return;
     lv_obj_invalidate(obj);
 }
 /**
@@ -1331,7 +1332,7 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
 {
     return -obj->scroll.y;
 }
@@ -1343,7 +1344,7 @@ lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -1367,7 +1368,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 {
     return -obj->scroll.x;
 }
@@ -1379,7 +1380,7 @@ lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -4006,33 +4007,10 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
     }
     else if(sign == LV_SIGNAL_SCROLL) {
-
+        res = lv_event_send(obj, LV_EVENT_SCROLLED, NULL);
+        if(res != LV_RES_OK) return res;
     }
     else if(sign == LV_SIGNAL_SCROLL_END) {
-
-        lv_coord_t st = lv_obj_get_scroll_top(obj);
-        lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
-        lv_coord_t sl = lv_obj_get_scroll_left(obj);
-        lv_coord_t sr = lv_obj_get_scroll_right(obj);
-
-        /*Revert if scrolled in*/
-        if(st > 0 || sb > 0) { /*Is vertically scrollable*/
-            if(st < 0) {
-                lv_obj_scroll_by(obj, 0, st, LV_ANIM_ON);
-            }
-            else if(sb < 0) {
-                lv_obj_scroll_by(obj, 0, -sb, LV_ANIM_ON);
-            }
-        }
-        if(sl > 0 || sr > 0) { /*Is horizontally scrollable*/
-            if(sl < 0) {
-                lv_obj_scroll_by(obj, sl, 0, LV_ANIM_ON);
-            }
-            else if(sr < 0) {
-                lv_obj_scroll_by(obj, -sr, 0, LV_ANIM_ON);
-            }
-        }
-
         if(lv_obj_get_scroll_mode(obj) == LV_SCROLL_MODE_ACTIVE) {
             lv_obj_invalidate(obj);
         }
@@ -4045,11 +4023,13 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         if(lv_obj_is_grid_item(obj)) lv_grid_full_refr(obj);
 
-//        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-//        while(child) {
-//            lv_obj_set_pos(child, child->x_set, child->y_set);
-//            child = lv_obj_get_child(obj, child);
-//        }
+        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+        while(child) {
+            if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+                lv_obj_set_pos(child, child->x_set, child->y_set);
+            }
+            child = lv_obj_get_child(obj, child);
+        }
 
 
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 0ad5e0593..f4afd1f0b 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -95,7 +95,7 @@ enum {
     LV_EVENT_SCROLL_BEGIN,
     LV_EVENT_SCROLL_THROW_BEGIN,
     LV_EVENT_SCROLL_END,
-    LV_EVENT_SCROLL,
+    LV_EVENT_SCROLLED,
     LV_EVENT_GESTURE,           /**< The object has been gesture*/
     LV_EVENT_KEY,
     LV_EVENT_FOCUSED,
@@ -123,15 +123,15 @@ typedef void (*lv_event_cb_t)(struct _lv_obj_t * obj, lv_event_t event);
   * on the object. */
 enum {
     /*General signals*/
-    LV_SIGNAL_CLEANUP, /**< Object is being deleted */
-    LV_SIGNAL_CHILD_CHG, /**< Child was removed/added */
-    LV_SIGNAL_COORD_CHG, /**< Object coordinates/size have changed */
-    LV_SIGNAL_STYLE_CHG,    /**< Object's style has changed */
-    LV_SIGNAL_BASE_DIR_CHG, /**<The base dir has changed*/
+    LV_SIGNAL_CLEANUP,           /**< Object is being deleted */
+    LV_SIGNAL_CHILD_CHG,         /**< Child was removed/added */
+    LV_SIGNAL_COORD_CHG,         /**< Object coordinates/size have changed */
+    LV_SIGNAL_STYLE_CHG,         /**< Object's style has changed */
+    LV_SIGNAL_BASE_DIR_CHG,      /**<The base dir has changed*/
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
-    LV_SIGNAL_GET_TYPE, /**< LVGL needs to retrieve the object's type */
-    LV_SIGNAL_GET_STYLE, /**<Get the style of an object*/
-    LV_SIGNAL_GET_STATE_DSC, /**<Get the state of the object*/
+    LV_SIGNAL_GET_TYPE,          /**< LVGL needs to retrieve the object's type */
+    LV_SIGNAL_GET_STYLE,         /**<Get the style of an object*/
+    LV_SIGNAL_GET_STATE_DSC,     /**<Get the state of the object*/
 
     /*Input device related*/
     LV_SIGNAL_HIT_TEST,          /**< Advanced hit-testing */
@@ -172,14 +172,7 @@ enum {
 typedef uint8_t lv_state_t;
 
 enum {
-    LV_SCROLL_SNAP_OFF,
-    LV_SCROLL_SNAP_NORMAL,
-    LV_SCROLL_SNAP_ALWAYS,
-};
-
-typedef uint8_t lv_scroll_snap_t;
-
-enum {
+    LV_SCROLL_SNAP_ALIGN_NONE,
     LV_SCROLL_SNAP_ALIGN_START,
     LV_SCROLL_SNAP_ALIGN_END,
     LV_SCROLL_SNAP_ALIGN_CENTER
@@ -188,15 +181,16 @@ typedef uint8_t lv_scroll_snap_align_t;
 
 
 enum {
-    LV_OBJ_FLAG_HIDDEN,
-    LV_OBJ_FLAG_CLICKABLE,
-    LV_OBJ_FLAG_SCROLLABLE,
-    LV_OBJ_FLAG_SCROLL_ELASTIC,
-    LV_OBJ_FLAG_SCROLL_MOMENTUM,
-    LV_OBJ_FLAG_PRESS_LOCK,
-    LV_OBJ_FLAG_EVENT_BUBBLE,
-    LV_OBJ_FLAG_GESTURE_BUBBLE,
-    LV_OBJ_FLAG_FOCUS_BUBBLE,
+    LV_OBJ_FLAG_HIDDEN          = (1 << 0),
+    LV_OBJ_FLAG_CLICKABLE       = (1 << 1),
+    LV_OBJ_FLAG_SCROLLABLE      = (1 << 2),
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 3),
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 4),
+    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 5),
+    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 6),
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 7),
+    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 8),
+    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 9),
 };
 typedef uint16_t lv_obj_flag_t;
 
@@ -235,12 +229,11 @@ typedef struct _lv_obj_t {
     /*Attributes and states*/
     lv_obj_flag_t flags     : 9;
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
-    lv_scroll_snap_t snap_x : 2;
-    lv_scroll_snap_t snap_y : 2;
     lv_scroll_snap_align_t snap_align_x : 2;
     lv_scroll_snap_align_t snap_align_y : 2;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
     uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
+
     lv_state_t state;
 
     lv_coord_t x_set;
@@ -548,7 +541,7 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj);
 
 /**
  * Return the height of the area below the parent.
@@ -557,7 +550,7 @@ lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
 
 
 /**
@@ -567,7 +560,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj);
 
 /**
  * Return the width of the area below the object.
@@ -576,7 +569,7 @@ lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj);
 
 /**
  * Set the size of an extended clickable area
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index 1b3ab3dc6..846bd63e4 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -139,6 +139,7 @@ typedef struct _lv_indev_proc_t {
                                                 other post-release event)*/
             struct _lv_obj_t * scroll_obj;      /*The object being scrolled*/
             struct _lv_obj_t * last_pressed; /*The lastly pressed object*/
+            lv_area_t scroll_area;
 
             lv_gesture_dir_t gesture_dir;
             lv_point_t gesture_sum; /*Count the gesture pixels to check LV_INDEV_DEF_GESTURE_LIMIT*/

From 6e08d402c1638a234c44e1f8ded2a186bfe20eac Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sat, 5 Sep 2020 13:34:58 +0200
Subject: [PATCH 24/84] add scroll direction enable/disable support

---
 src/lv_core/lv_indev.c | 50 ++++++++++++++++++++++++++++++++----------
 src/lv_core/lv_obj.c   |  1 +
 src/lv_core/lv_obj.h   | 14 ++++++++++++
 3 files changed, 53 insertions(+), 12 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index c48d808fa..d0bf98d06 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1256,13 +1256,12 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
         child = lv_obj_get_child_back(obj, child);
     }
 
-    printf("child cnt: %d\n", cc);
-
     return dist == LV_COORD_MAX ? 0 : -dist;
 }
 
 static void scroll_limit(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y)
 {
+    lv_obj_t * obj = proc->types.pointer.scroll_obj;
     if(diff_y) {
         if(proc->types.pointer.scroll_sum.y + *diff_y < proc->types.pointer.scroll_area.y1) {
            *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
@@ -1301,8 +1300,16 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
 
         proc->types.pointer.scroll_obj = proc->types.pointer.act_obj;
 
-        /*Go until find an scrollable object in the current direction*/
+        /* Go until find an scrollable object in the current direction
+         * More precisely:
+         *  1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
+         *  2. Scrollable means it has some content out of it's area
+         *  3. If an object can be scrolled into the current direction then use it ("real match"")
+         *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
+         *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
         while(proc->types.pointer.scroll_obj) {
+
+            /*Decide if it's a horizontal or vertical scroll*/
             bool hor_en = false;
             bool ver_en = false;
             if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
@@ -1312,28 +1319,38 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
                 ver_en = true;
             }
 
+            /*Consider both up-down or left/right scrollable according to the current direction*/
             bool up_en = ver_en;
             bool down_en = ver_en;
             bool left_en = hor_en;
             bool right_en = hor_en;
 
+            /*The object might have disabled some directions.*/
+            lv_dir_t scroll_dir = proc->types.pointer.scroll_obj->scroll_dir;
+            if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
+            if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
+            if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
+            if((scroll_dir & LV_DIR_BOTTOM) == 0) down_en = false;
+
+            /*The object is scrollable to a direction if its content overflow in that direction. */
             lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.scroll_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.scroll_obj);
             lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.scroll_obj);
             lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.scroll_obj);
 
-            bool ver_scrollable = st > 0 || sb > 0 ? true : false;
-            bool hor_scrollable = sl > 0 || sr > 0 ? true : false;
-
-            if(ver_scrollable &&
-               ((up_en    && proc->types.pointer.scroll_sum.y >=   indev_act->driver.scroll_limit) ||
-                (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit)))
+            /* If this object is scrollable into the current scroll direction then save it as a candidate.
+             * It's important only to be scrollable on the current axis (hor/ver) because if the scroll
+             * is propagated to this object it can show at least elastic scroll effect.
+             * But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate) */
+            if((st > 0 || sb > 0)  &&
+              ((up_en    && proc->types.pointer.scroll_sum.y >= indev_act->driver.scroll_limit) ||
+               (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit)))
             {
                 scroll_candidate_obj = proc->types.pointer.scroll_obj;
                 dirs_candidate = LV_SCROLL_DIR_VER;
             }
 
-            if(hor_scrollable &&
+            if((sl > 0 || sr > 0)  &&
               ((left_en    && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
                (right_en  && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit)))
             {
@@ -1341,19 +1358,23 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
                 dirs_candidate = LV_SCROLL_DIR_HOR;
             }
 
+            /**/
             if(st <= 0) up_en = false;
             if(sb <= 0) down_en = false;
             if(sl <= 0) left_en = false;
             if(sr <= 0) right_en = false;
 
+            /*If the object really can be scrolled into the current direction the use it. */
             if((left_en  && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
                (right_en && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit) ||
                (up_en    && proc->types.pointer.scroll_sum.y >=   indev_act->driver.scroll_limit) ||
                (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit))
             {
                 proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
-                break;  /*It's good scrollable object, use it*/
+                break;
             }
+
+            /*Try the parent */
             proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
         }
 
@@ -1381,7 +1402,6 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
             case LV_SCROLL_SNAP_ALIGN_START:
                 proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
                 proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
-                printf("%d, %d\n", proc->types.pointer.scroll_area.y1, proc->types.pointer.scroll_area.y2);
                 break;
             case LV_SCROLL_SNAP_ALIGN_END:
                 proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
@@ -1441,6 +1461,12 @@ static void indev_scroll_handler(lv_indev_proc_t * proc)
             if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
         }
 
+
+        if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
+
         /*Respect the scroll limit area*/
         scroll_limit(proc, &diff_x, &diff_y);
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 2e7e05584..780ac26b5 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -330,6 +330,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     /*Set attributes*/
     new_obj->adv_hittest  = 0;
     new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
+    new_obj->scroll_dir  = LV_DIR_ALL;
     new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
     if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index f4afd1f0b..a3830df74 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -171,6 +171,19 @@ enum {
 
 typedef uint8_t lv_state_t;
 
+enum {
+    LV_DIR_NONE     = 0x00,
+    LV_DIR_LEFT     = (1 << 0),
+    LV_DIR_RIGHT    = (1 << 1),
+    LV_DIR_TOP      = (1 << 2),
+    LV_DIR_BOTTOM   = (1 << 3),
+    LV_DIR_HOR      = LV_DIR_LEFT | LV_DIR_RIGHT,
+    LV_DIR_VER      = LV_DIR_TOP | LV_DIR_BOTTOM,
+    LV_DIR_ALL      = LV_DIR_HOR | LV_DIR_VER,
+};
+
+typedef uint8_t lv_dir_t;
+
 enum {
     LV_SCROLL_SNAP_ALIGN_NONE,
     LV_SCROLL_SNAP_ALIGN_START,
@@ -231,6 +244,7 @@ typedef struct _lv_obj_t {
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
     lv_scroll_snap_align_t snap_align_x : 2;
     lv_scroll_snap_align_t snap_align_y : 2;
+    lv_scroll_dir_t scroll_dir :4;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
     uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
 

From 9c638950bb51d778fd28af04b546fd4a468cfe87 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sat, 5 Sep 2020 14:15:39 +0200
Subject: [PATCH 25/84] add lv_scroll.c/h to keep scroll related code in one
 place

---
 src/lv_core/lv_indev.c  | 443 +-----------------------------------
 src/lv_core/lv_scroll.c | 489 ++++++++++++++++++++++++++++++++++++++++
 src/lv_core/lv_scroll.h |  51 +++++
 3 files changed, 548 insertions(+), 435 deletions(-)
 create mode 100644 src/lv_core/lv_scroll.c
 create mode 100644 src/lv_core/lv_scroll.h

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index d0bf98d06..5f3157b2c 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -9,6 +9,7 @@
 #include "lv_indev.h"
 #include "lv_disp.h"
 #include "lv_obj.h"
+#include "lv_scroll.h"
 
 #include "../lv_hal/lv_hal_tick.h"
 #include "../lv_core/lv_group.h"
@@ -40,8 +41,6 @@ static void indev_proc_press(lv_indev_proc_t * proc);
 static void indev_proc_release(lv_indev_proc_t * proc);
 static void indev_proc_reset_query_handler(lv_indev_t * indev);
 static void indev_click_focus(lv_indev_proc_t * proc);
-static void indev_scroll_handler(lv_indev_proc_t * proc);
-static void indev_scroll_throw_handler(lv_indev_proc_t * proc);
 static void indev_gesture(lv_indev_proc_t * proc);
 static bool indev_reset_check(lv_indev_proc_t * proc);
 
@@ -844,7 +843,8 @@ static void indev_proc_press(lv_indev_proc_t * proc)
     if(new_obj_searched && proc->types.pointer.last_obj) {
         proc->types.pointer.scroll_throw_vect.x = 0;
         proc->types.pointer.scroll_throw_vect.y = 0;
-        indev_scroll_throw_handler(proc);
+        _lv_scroll_throw_handler(proc);
+        if(indev_reset_check(proc)) return;
     }
 
     /*Do not use disabled objects*/
@@ -918,7 +918,8 @@ static void indev_proc_press(lv_indev_proc_t * proc)
 
         if(indev_act->proc.wait_until_release) return;
 
-        indev_scroll_handler(proc);
+        _lv_scroll_handler(proc);
+        if(indev_reset_check(proc)) return;
         indev_gesture(proc);
         if(indev_reset_check(proc)) return;
 
@@ -1009,7 +1010,7 @@ static void indev_proc_release(lv_indev_proc_t * proc)
     /*The reset can be set in the signal function.
      * In case of reset query ignore the remaining parts.*/
     if(scroll_obj) {
-        indev_scroll_throw_handler(proc);
+        _lv_scroll_throw_handler(proc);
         if(indev_reset_check(proc)) return;
     }
 }
@@ -1176,440 +1177,11 @@ static void indev_click_focus(lv_indev_proc_t * proc)
 }
 
 
-static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
-{
-    if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
-
-    lv_coord_t dist = LV_COORD_MAX;
-
-    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
-    while(child) {
-        lv_coord_t x_child = 0;
-        lv_coord_t x_parent = 0;
-        switch(obj->snap_align_x) {
-        case LV_SCROLL_SNAP_ALIGN_START:
-            x_child = child->coords.x1;
-            x_parent = obj->coords.x1;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_END:
-            x_child = child->coords.x2;
-            x_parent = obj->coords.x2;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_CENTER:
-            x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
-            x_parent = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
-        }
-
-        x_child += ofs;
-        if(x_child >= min && x_child <= max) {
-            lv_coord_t x = x_child -  x_parent;
-            if(LV_MATH_ABS(x) < LV_MATH_ABS(dist)) dist = x;
-        }
-
-        child = lv_obj_get_child_back(obj, child);
-    }
-
-    return dist == LV_COORD_MAX ? 0: -dist;
-}
-
-/**
- * Search for snap point in the `min` - `max` range.
- * @param obj the object on which snap point should be found
- * @param min ignore snap points smaller then this. (Absolute coordinate)
- * @param max ignore snap points greater then this. (Absolute coordinate)
- * @param ofs offset to snap points. Useful the get a snap point in an imagined case
- *            what if children are already moved by this value
- * @return the distance of the snap point.
- */
-static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
-{
-    if(obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
-
-    lv_coord_t dist = LV_COORD_MAX;
-
-    uint32_t cc = 0;
-    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
-    while(child) {
-        cc++;
-        lv_coord_t y_child = 0;
-        lv_coord_t y_parent = 0;
-        switch(obj->snap_align_y) {
-        case LV_SCROLL_SNAP_ALIGN_START:
-            y_child = child->coords.y1;
-            y_parent = obj->coords.y1;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_END:
-            y_child = child->coords.y2;
-            y_parent = obj->coords.y2;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_CENTER:
-            y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
-            y_parent = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
-        }
-
-        y_child += ofs;
-        if(y_child >= min && y_child <= max) {
-            lv_coord_t y = y_child -  y_parent;
-            if(LV_MATH_ABS(y) < LV_MATH_ABS(dist)) dist = y;
-        }
-
-        child = lv_obj_get_child_back(obj, child);
-    }
-
-    return dist == LV_COORD_MAX ? 0 : -dist;
-}
-
-static void scroll_limit(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y)
-{
-    lv_obj_t * obj = proc->types.pointer.scroll_obj;
-    if(diff_y) {
-        if(proc->types.pointer.scroll_sum.y + *diff_y < proc->types.pointer.scroll_area.y1) {
-           *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
-        }
-
-        if(proc->types.pointer.scroll_sum.y + *diff_y > proc->types.pointer.scroll_area.y2) {
-            *diff_y = proc->types.pointer.scroll_area.y2 - proc->types.pointer.scroll_sum.y;
-        }
-    }
-
-    if(diff_x) {
-        if(proc->types.pointer.scroll_sum.x + *diff_x < proc->types.pointer.scroll_area.x1) {
-            *diff_x = proc->types.pointer.scroll_area.x1 - proc->types.pointer.scroll_sum.x;
-        }
-
-        if(proc->types.pointer.scroll_sum.x + *diff_x > proc->types.pointer.scroll_area.x2) {
-            *diff_x = proc->types.pointer.scroll_area.x2 - proc->types.pointer.scroll_sum.x;
-        }
-    }
-}
-
-
-/**
- * Handle the scrolling
- * @param indev pointer to a input device state
- */
-static void indev_scroll_handler(lv_indev_proc_t * proc)
-{
-    lv_obj_t * scroll_candidate_obj = NULL;
-    lv_scroll_dir_t dirs_candidate = LV_SCROLL_DIR_NONE;
-
-    /*If there is no scroll object yet try to find one*/
-    if(proc->types.pointer.scroll_obj == NULL) {
-        proc->types.pointer.scroll_sum.x += proc->types.pointer.vect.x;
-        proc->types.pointer.scroll_sum.y += proc->types.pointer.vect.y;
-
-        proc->types.pointer.scroll_obj = proc->types.pointer.act_obj;
-
-        /* Go until find an scrollable object in the current direction
-         * More precisely:
-         *  1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
-         *  2. Scrollable means it has some content out of it's area
-         *  3. If an object can be scrolled into the current direction then use it ("real match"")
-         *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
-         *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
-        while(proc->types.pointer.scroll_obj) {
-
-            /*Decide if it's a horizontal or vertical scroll*/
-            bool hor_en = false;
-            bool ver_en = false;
-            if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
-                hor_en = true;
-            }
-            else {
-                ver_en = true;
-            }
-
-            /*Consider both up-down or left/right scrollable according to the current direction*/
-            bool up_en = ver_en;
-            bool down_en = ver_en;
-            bool left_en = hor_en;
-            bool right_en = hor_en;
-
-            /*The object might have disabled some directions.*/
-            lv_dir_t scroll_dir = proc->types.pointer.scroll_obj->scroll_dir;
-            if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
-            if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
-            if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
-            if((scroll_dir & LV_DIR_BOTTOM) == 0) down_en = false;
-
-            /*The object is scrollable to a direction if its content overflow in that direction. */
-            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.scroll_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.scroll_obj);
-            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.scroll_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.scroll_obj);
-
-            /* If this object is scrollable into the current scroll direction then save it as a candidate.
-             * It's important only to be scrollable on the current axis (hor/ver) because if the scroll
-             * is propagated to this object it can show at least elastic scroll effect.
-             * But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate) */
-            if((st > 0 || sb > 0)  &&
-              ((up_en    && proc->types.pointer.scroll_sum.y >= indev_act->driver.scroll_limit) ||
-               (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit)))
-            {
-                scroll_candidate_obj = proc->types.pointer.scroll_obj;
-                dirs_candidate = LV_SCROLL_DIR_VER;
-            }
-
-            if((sl > 0 || sr > 0)  &&
-              ((left_en    && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
-               (right_en  && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit)))
-            {
-                scroll_candidate_obj = proc->types.pointer.scroll_obj;
-                dirs_candidate = LV_SCROLL_DIR_HOR;
-            }
-
-            /**/
-            if(st <= 0) up_en = false;
-            if(sb <= 0) down_en = false;
-            if(sl <= 0) left_en = false;
-            if(sr <= 0) right_en = false;
-
-            /*If the object really can be scrolled into the current direction the use it. */
-            if((left_en  && proc->types.pointer.scroll_sum.x >=   indev_act->driver.scroll_limit) ||
-               (right_en && proc->types.pointer.scroll_sum.x <= - indev_act->driver.scroll_limit) ||
-               (up_en    && proc->types.pointer.scroll_sum.y >=   indev_act->driver.scroll_limit) ||
-               (down_en  && proc->types.pointer.scroll_sum.y <= - indev_act->driver.scroll_limit))
-            {
-                proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
-                break;
-            }
-
-            /*Try the parent */
-            proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
-        }
-
-        /*Use the last candidate*/
-        if(proc->types.pointer.scroll_obj == NULL) {
-            if(scroll_candidate_obj) {
-                proc->types.pointer.scroll_dir = dirs_candidate;
-                proc->types.pointer.scroll_obj = scroll_candidate_obj;
-            } else {
-                return;
-            }
-        }
-
-        proc->types.pointer.scroll_sum.x = 0;
-        proc->types.pointer.scroll_sum.y = 0;
-
-        lv_obj_t * obj = proc->types.pointer.scroll_obj;
-        /*If there no STOP allow scrolling anywhere*/
-        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_STOP) == false) {
-            lv_area_set(&proc->types.pointer.scroll_area, LV_COORD_MIN, LV_COORD_MIN, LV_COORD_MAX, LV_COORD_MAX);
-        }
-        /*With STOP limit the scrolling to the perv and next snap point*/
-        else {
-            switch(obj->snap_align_y) {
-            case LV_SCROLL_SNAP_ALIGN_START:
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_END:
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_CENTER: {
-                lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
-                break;
-            }
-            default:
-                proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
-                proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
-                break;
-            }
-
-            switch(obj->snap_align_x) {
-            case LV_SCROLL_SNAP_ALIGN_START:
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_END:
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_CENTER: {
-                lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
-                break;
-            }
-            default:
-                proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
-                proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
-                break;
-            }
-        }
-    }
-
-    /*If there is no scroll object there is nothing to do*/
-    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
-    if(scroll_obj == NULL) return;
-
-    /*Set new position or scroll if the vector is not zero*/
-    if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
-        lv_coord_t diff_x = 0;
-        lv_coord_t diff_y = 0;
-
-        if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
-            diff_x = proc->types.pointer.vect.x;
-            if(lv_obj_get_scroll_right(scroll_obj) < 0) diff_x = diff_x / 2;
-            if(lv_obj_get_scroll_left(scroll_obj) < 0) diff_x = diff_x / 2;
-        } else {
-            diff_y = proc->types.pointer.vect.y;
-            if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
-            if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
-        }
-
-
-        if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
-
-        /*Respect the scroll limit area*/
-        scroll_limit(proc, &diff_x, &diff_y);
-
-        lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
-        proc->types.pointer.scroll_sum.x += diff_x;
-        proc->types.pointer.scroll_sum.y += diff_y;
-    }
-}
-
-static lv_coord_t scroll_throw_predict_y(lv_indev_proc_t * proc)
-{
-    lv_coord_t y =  proc->types.pointer.scroll_throw_vect.y;
-    lv_coord_t move = 0;
-    while(y) {
-        move += y;
-        y = y * (100 - indev_act->driver.scroll_throw) / 100;
-    }
-    return move;
-}
-
-
-static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc)
-{
-    lv_coord_t x =  proc->types.pointer.scroll_throw_vect.x;
-    lv_coord_t move = 0;
-    while(x) {
-        move += x;
-        x = x * (100 - indev_act->driver.scroll_throw) / 100;
-    }
-    return move;
-}
-
-/**
- * Handle throwing by after scrolling
- * @param indev pointer to an input device state
- */
-static void indev_scroll_throw_handler(lv_indev_proc_t * proc)
-{
-    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
-
-    if(scroll_obj == NULL) return;
-    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) {
-        return;
-    }
-    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
-        proc->types.pointer.scroll_throw_vect.x = 0;
-        /*If no snapping "throw"*/
-        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
-            proc->types.pointer.scroll_throw_vect.y =
-                    proc->types.pointer.scroll_throw_vect.y * (100 - indev_act->driver.scroll_throw) / 100;
-
-            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
-
-            /*If scrolled inside reduce faster*/
-            if(st < 0 || sb < 0) {
-                proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
-            }
-
-            lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
-        }
-        /*With snapping find the nearest snap point and scroll there*/
-        else {
-            lv_coord_t diff_y = scroll_throw_predict_y(proc);
-            proc->types.pointer.scroll_throw_vect.y = 0;
-            scroll_limit(proc, NULL, &diff_y);
-            lv_coord_t y = find_snap_point_y(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_y);
-            lv_obj_scroll_by(scroll_obj, 0, diff_y + y, LV_ANIM_ON);
-        }
-    }
-    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
-        proc->types.pointer.scroll_throw_vect.y = 0;
-        /*If no snapping "throw"*/
-        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
-            proc->types.pointer.scroll_throw_vect.x =
-                    proc->types.pointer.scroll_throw_vect.x * (100 - indev_act->driver.scroll_throw) / 100;
-
-            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
-
-            /*If scrolled inside reduce faster*/
-            if(sl < 0 || sr < 0) {
-                proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
-            }
-
-            lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
-        }
-        /*With snapping find the nearest snap point and scroll there*/
-        else {
-            lv_coord_t diff_x = scroll_throw_predict_x(proc);
-            proc->types.pointer.scroll_throw_vect.x = 0;
-            scroll_limit(proc, NULL, &diff_x);
-            lv_coord_t x = find_snap_point_x(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_x);
-            lv_obj_scroll_by(scroll_obj, x + diff_x, 0, LV_ANIM_ON);
-        }
-    }
-
-
-    /*Check if the scroll has finished */
-    if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
-        /*Revert if scrolled in*/
-        /*If vertically scrollable and not controlled by snap*/
-        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
-            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
-            if(st > 0 || sb > 0) {
-                if(st < 0) {
-                    lv_obj_scroll_by(scroll_obj, 0, st, LV_ANIM_ON);
-                }
-                else if(sb < 0) {
-                    lv_obj_scroll_by(scroll_obj, 0, -sb, LV_ANIM_ON);
-                }
-            }
-        }
-
-        /*If horizontally scrollable and not controlled by snap*/
-        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
-            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
-            if (sl > 0 || sr > 0) {
-                if(sl < 0) {
-                    lv_obj_scroll_by(scroll_obj, sl, 0, LV_ANIM_ON);
-                }
-                else if(sr < 0) {
-                    lv_obj_scroll_by(scroll_obj, -sr, 0, LV_ANIM_ON);
-                }
-            }
-        }
-
-        proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
-        proc->types.pointer.scroll_obj = NULL;
-        lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_END, indev_act);
-        if(indev_reset_check(proc)) return;
-        lv_event_send(scroll_obj, LV_EVENT_SCROLL_END, indev_act);
-        if(indev_reset_check(proc)) return;
-    }
-}
-
 /**
 * Handle the gesture of indev_proc_p->types.pointer.act_obj
 * @param indev pointer to a input device state
 */
-static void indev_gesture(lv_indev_proc_t * proc)
+void indev_gesture(lv_indev_proc_t * proc)
 {
 
     if(proc->types.pointer.scroll_obj) return;
@@ -1661,6 +1233,7 @@ static void indev_gesture(lv_indev_proc_t * proc)
 }
 
 
+
 /**
  * Checks if the reset_query flag has been set. If so, perform necessary global indev cleanup actions
  * @param proc pointer to an input device 'proc'
diff --git a/src/lv_core/lv_scroll.c b/src/lv_core/lv_scroll.c
new file mode 100644
index 000000000..9fc7e5155
--- /dev/null
+++ b/src/lv_core/lv_scroll.c
@@ -0,0 +1,489 @@
+/**
+ * @file lv_scroll.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_scroll.h"
+#include "lv_indev.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs);
+static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs);
+static void scroll_limit_diff(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y);
+static lv_coord_t scroll_throw_predict_y(lv_indev_proc_t * proc);
+static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Handle scrolling. Called by LVGL during input device processing
+ * @param proc pointer to an input device's proc field
+ */
+void _lv_scroll_handler(lv_indev_proc_t * proc)
+{
+    lv_obj_t * scroll_candidate_obj = NULL;
+    lv_scroll_dir_t dirs_candidate = LV_SCROLL_DIR_NONE;
+
+    lv_indev_t * indev_act = lv_indev_get_act();
+    lv_coord_t scroll_limit =  indev_act->driver.scroll_limit;
+
+    /*If there is no scroll object yet try to find one*/
+    if(proc->types.pointer.scroll_obj == NULL) {
+        proc->types.pointer.scroll_sum.x += proc->types.pointer.vect.x;
+        proc->types.pointer.scroll_sum.y += proc->types.pointer.vect.y;
+
+        proc->types.pointer.scroll_obj = proc->types.pointer.act_obj;
+
+        /* Go until find an scrollable object in the current direction
+         * More precisely:
+         *  1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
+         *  2. Scrollable means it has some content out of it's area
+         *  3. If an object can be scrolled into the current direction then use it ("real match"")
+         *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
+         *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
+        while(proc->types.pointer.scroll_obj) {
+
+            /*Decide if it's a horizontal or vertical scroll*/
+            bool hor_en = false;
+            bool ver_en = false;
+            if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
+                hor_en = true;
+            }
+            else {
+                ver_en = true;
+            }
+
+            /*Consider both up-down or left/right scrollable according to the current direction*/
+            bool up_en = ver_en;
+            bool down_en = ver_en;
+            bool left_en = hor_en;
+            bool right_en = hor_en;
+
+            /*The object might have disabled some directions.*/
+            lv_dir_t scroll_dir = proc->types.pointer.scroll_obj->scroll_dir;
+            if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
+            if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
+            if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
+            if((scroll_dir & LV_DIR_BOTTOM) == 0) down_en = false;
+
+            /*The object is scrollable to a direction if its content overflow in that direction. */
+            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.scroll_obj);
+            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.scroll_obj);
+
+            /* If this object is scrollable into the current scroll direction then save it as a candidate.
+             * It's important only to be scrollable on the current axis (hor/ver) because if the scroll
+             * is propagated to this object it can show at least elastic scroll effect.
+             * But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate) */
+            if((st > 0 || sb > 0)  &&
+              ((up_en    && proc->types.pointer.scroll_sum.y >= scroll_limit) ||
+               (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit)))
+            {
+                scroll_candidate_obj = proc->types.pointer.scroll_obj;
+                dirs_candidate = LV_SCROLL_DIR_VER;
+            }
+
+            if((sl > 0 || sr > 0)  &&
+              ((left_en    && proc->types.pointer.scroll_sum.x >=  scroll_limit) ||
+               (right_en  && proc->types.pointer.scroll_sum.x <= - scroll_limit)))
+            {
+                scroll_candidate_obj = proc->types.pointer.scroll_obj;
+                dirs_candidate = LV_SCROLL_DIR_HOR;
+            }
+
+            /**/
+            if(st <= 0) up_en = false;
+            if(sb <= 0) down_en = false;
+            if(sl <= 0) left_en = false;
+            if(sr <= 0) right_en = false;
+
+            /*If the object really can be scrolled into the current direction the use it. */
+            if((left_en  && proc->types.pointer.scroll_sum.x >=   scroll_limit) ||
+               (right_en && proc->types.pointer.scroll_sum.x <= - scroll_limit) ||
+               (up_en    && proc->types.pointer.scroll_sum.y >=   scroll_limit) ||
+               (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit))
+            {
+                proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
+                break;
+            }
+
+            /*Try the parent */
+            proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
+        }
+
+        /*Use the last candidate*/
+        if(proc->types.pointer.scroll_obj == NULL) {
+            if(scroll_candidate_obj) {
+                proc->types.pointer.scroll_dir = dirs_candidate;
+                proc->types.pointer.scroll_obj = scroll_candidate_obj;
+            } else {
+                return;
+            }
+        }
+
+        proc->types.pointer.scroll_sum.x = 0;
+        proc->types.pointer.scroll_sum.y = 0;
+
+        lv_obj_t * obj = proc->types.pointer.scroll_obj;
+        /*If there no STOP allow scrolling anywhere*/
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_STOP) == false) {
+            lv_area_set(&proc->types.pointer.scroll_area, LV_COORD_MIN, LV_COORD_MIN, LV_COORD_MAX, LV_COORD_MAX);
+        }
+        /*With STOP limit the scrolling to the perv and next snap point*/
+        else {
+            switch(obj->snap_align_y) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER: {
+                lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
+                break;
+            }
+            default:
+                proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
+                break;
+            }
+
+            switch(obj->snap_align_x) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER: {
+                lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
+                break;
+            }
+            default:
+                proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
+                break;
+            }
+        }
+    }
+
+    /*If there is no scroll object there is nothing to do*/
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
+    if(scroll_obj == NULL) return;
+
+    /*Set new position or scroll if the vector is not zero*/
+    if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
+        lv_coord_t diff_x = 0;
+        lv_coord_t diff_y = 0;
+
+        if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
+            diff_x = proc->types.pointer.vect.x;
+            if(lv_obj_get_scroll_right(scroll_obj) < 0) diff_x = diff_x / 2;
+            if(lv_obj_get_scroll_left(scroll_obj) < 0) diff_x = diff_x / 2;
+        } else {
+            diff_y = proc->types.pointer.vect.y;
+            if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
+            if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
+        }
+
+
+        if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
+        if((scroll_obj->scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
+
+        /*Respect the scroll limit area*/
+        scroll_limit_diff(proc, &diff_x, &diff_y);
+
+        lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
+        proc->types.pointer.scroll_sum.x += diff_x;
+        proc->types.pointer.scroll_sum.y += diff_y;
+    }
+}
+
+
+/**
+ * Handle throwing after scrolling. Called by LVGL during input device processing
+ * @param proc pointer to an input device's proc field
+ */
+void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
+{
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
+    if(scroll_obj == NULL) return;
+
+    lv_indev_t * indev_act = lv_indev_get_act();
+    lv_coord_t scroll_throw =  indev_act->driver.scroll_throw;
+
+    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) {
+        return;
+    }
+    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
+        proc->types.pointer.scroll_throw_vect.x = 0;
+        /*If no snapping "throw"*/
+        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+            proc->types.pointer.scroll_throw_vect.y =
+                    proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
+
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+
+            /*If scrolled inside reduce faster*/
+            if(st < 0 || sb < 0) {
+                proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
+            }
+
+            lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
+        }
+        /*With snapping find the nearest snap point and scroll there*/
+        else {
+            lv_coord_t diff_y = scroll_throw_predict_y(proc);
+            proc->types.pointer.scroll_throw_vect.y = 0;
+            scroll_limit_diff(proc, NULL, &diff_y);
+            lv_coord_t y = find_snap_point_y(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_y);
+            lv_obj_scroll_by(scroll_obj, 0, diff_y + y, LV_ANIM_ON);
+        }
+    }
+    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
+        proc->types.pointer.scroll_throw_vect.y = 0;
+        /*If no snapping "throw"*/
+        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+            proc->types.pointer.scroll_throw_vect.x =
+                    proc->types.pointer.scroll_throw_vect.x * (100 - scroll_throw) / 100;
+
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
+
+            /*If scrolled inside reduce faster*/
+            if(sl < 0 || sr < 0) {
+                proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
+            }
+
+            lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
+        }
+        /*With snapping find the nearest snap point and scroll there*/
+        else {
+            lv_coord_t diff_x = scroll_throw_predict_x(proc);
+            proc->types.pointer.scroll_throw_vect.x = 0;
+            scroll_limit_diff(proc, NULL, &diff_x);
+            lv_coord_t x = find_snap_point_x(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_x);
+            lv_obj_scroll_by(scroll_obj, x + diff_x, 0, LV_ANIM_ON);
+        }
+    }
+
+
+    /*Check if the scroll has finished */
+    if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
+        /*Revert if scrolled in*/
+        /*If vertically scrollable and not controlled by snap*/
+        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+            if(st > 0 || sb > 0) {
+                if(st < 0) {
+                    lv_obj_scroll_by(scroll_obj, 0, st, LV_ANIM_ON);
+                }
+                else if(sb < 0) {
+                    lv_obj_scroll_by(scroll_obj, 0, -sb, LV_ANIM_ON);
+                }
+            }
+        }
+
+        /*If horizontally scrollable and not controlled by snap*/
+        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
+            if (sl > 0 || sr > 0) {
+                if(sl < 0) {
+                    lv_obj_scroll_by(scroll_obj, sl, 0, LV_ANIM_ON);
+                }
+                else if(sr < 0) {
+                    lv_obj_scroll_by(scroll_obj, -sr, 0, LV_ANIM_ON);
+                }
+            }
+        }
+
+        proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
+        proc->types.pointer.scroll_obj = NULL;
+        lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_END, indev_act);
+        if(proc->reset_query) return;
+        lv_event_send(scroll_obj, LV_EVENT_SCROLL_END, indev_act);
+        if(proc->reset_query) return;
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
+{
+    if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+
+    lv_coord_t dist = LV_COORD_MAX;
+
+    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
+    while(child) {
+        lv_coord_t x_child = 0;
+        lv_coord_t x_parent = 0;
+        switch(obj->snap_align_x) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            x_child = child->coords.x1;
+            x_parent = obj->coords.x1;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            x_child = child->coords.x2;
+            x_parent = obj->coords.x2;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER:
+            x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
+            x_parent = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+        }
+
+        x_child += ofs;
+        if(x_child >= min && x_child <= max) {
+            lv_coord_t x = x_child -  x_parent;
+            if(LV_MATH_ABS(x) < LV_MATH_ABS(dist)) dist = x;
+        }
+
+        child = lv_obj_get_child_back(obj, child);
+    }
+
+    return dist == LV_COORD_MAX ? 0: -dist;
+}
+
+/**
+ * Search for snap point in the `min` - `max` range.
+ * @param obj the object on which snap point should be found
+ * @param min ignore snap points smaller then this. (Absolute coordinate)
+ * @param max ignore snap points greater then this. (Absolute coordinate)
+ * @param ofs offset to snap points. Useful the get a snap point in an imagined case
+ *            what if children are already moved by this value
+ * @return the distance of the snap point.
+ */
+static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
+{
+    if(obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+
+    lv_coord_t dist = LV_COORD_MAX;
+
+    uint32_t cc = 0;
+    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
+    while(child) {
+        cc++;
+        lv_coord_t y_child = 0;
+        lv_coord_t y_parent = 0;
+        switch(obj->snap_align_y) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            y_child = child->coords.y1;
+            y_parent = obj->coords.y1;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            y_child = child->coords.y2;
+            y_parent = obj->coords.y2;
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER:
+            y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
+            y_parent = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+        }
+
+        y_child += ofs;
+        if(y_child >= min && y_child <= max) {
+            lv_coord_t y = y_child -  y_parent;
+            if(LV_MATH_ABS(y) < LV_MATH_ABS(dist)) dist = y;
+        }
+
+        child = lv_obj_get_child_back(obj, child);
+    }
+
+    return dist == LV_COORD_MAX ? 0 : -dist;
+}
+
+static void scroll_limit_diff(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y)
+{
+    if(diff_y) {
+        if(proc->types.pointer.scroll_sum.y + *diff_y < proc->types.pointer.scroll_area.y1) {
+           *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
+        }
+
+        if(proc->types.pointer.scroll_sum.y + *diff_y > proc->types.pointer.scroll_area.y2) {
+            *diff_y = proc->types.pointer.scroll_area.y2 - proc->types.pointer.scroll_sum.y;
+        }
+    }
+
+    if(diff_x) {
+        if(proc->types.pointer.scroll_sum.x + *diff_x < proc->types.pointer.scroll_area.x1) {
+            *diff_x = proc->types.pointer.scroll_area.x1 - proc->types.pointer.scroll_sum.x;
+        }
+
+        if(proc->types.pointer.scroll_sum.x + *diff_x > proc->types.pointer.scroll_area.x2) {
+            *diff_x = proc->types.pointer.scroll_area.x2 - proc->types.pointer.scroll_sum.x;
+        }
+    }
+}
+
+
+
+static lv_coord_t scroll_throw_predict_y(lv_indev_proc_t * proc)
+{
+    lv_coord_t y =  proc->types.pointer.scroll_throw_vect.y;
+    lv_coord_t move = 0;
+
+    lv_indev_t * indev_act = lv_indev_get_act();
+    lv_coord_t scroll_throw =  indev_act->driver.scroll_throw;
+
+    while(y) {
+        move += y;
+        y = y * (100 - scroll_throw) / 100;
+    }
+    return move;
+}
+
+
+static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc)
+{
+    lv_coord_t x =  proc->types.pointer.scroll_throw_vect.x;
+    lv_coord_t move = 0;
+
+    lv_indev_t * indev_act = lv_indev_get_act();
+    lv_coord_t scroll_throw =  indev_act->driver.scroll_throw;
+
+    while(x) {
+        move += x;
+        x = x * (100 - scroll_throw) / 100;
+    }
+    return move;
+}
+
diff --git a/src/lv_core/lv_scroll.h b/src/lv_core/lv_scroll.h
new file mode 100644
index 000000000..293efd592
--- /dev/null
+++ b/src/lv_core/lv_scroll.h
@@ -0,0 +1,51 @@
+/**
+ * @file lv_scroll.h
+ *
+ */
+
+#ifndef LV_SCROLL_H
+#define LV_SCROLL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Handle scrolling. Called by LVGL during input device processing
+ * @param proc pointer to an input device's proc field
+ */
+void _lv_scroll_handler(lv_indev_proc_t * proc);
+
+
+/**
+ * Handle throwing after scrolling. Called by LVGL during input device processing
+ * @param proc pointer to an input device's proc field
+ */
+void _lv_scroll_throw_handler(lv_indev_proc_t * proc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_SCROLL_H*/

From 10e07270154b92376a741f063e883993d50e8ae6 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sun, 6 Sep 2020 14:25:42 +0200
Subject: [PATCH 26/84] move some part of lv_obj.c to lv_obj_pos.v and
 lv_obj_scroll.c

---
 src/lv_core/lv_disp.c                         |    6 +-
 src/lv_core/lv_grid.c                         |  160 +
 src/lv_core/lv_grid.h                         |    7 +
 src/lv_core/lv_indev.c                        |    6 +-
 src/lv_core/lv_indev.h                        |    2 +-
 .../{lv_scroll.c => lv_indev_scroll.c}        |    8 +-
 .../{lv_scroll.h => lv_indev_scroll.h}        |    8 +-
 src/lv_core/lv_obj.c                          | 2568 +----------------
 src/lv_core/lv_obj.h                          |  531 +---
 src/lv_core/lv_obj_pos.c                      |  670 +++++
 src/lv_core/lv_obj_pos.h                      |  241 ++
 src/lv_core/lv_obj_scroll.c                   |  246 ++
 src/lv_core/lv_obj_scroll.h                   |  153 +
 src/lv_core/lv_obj_style.c                    | 1366 +++++++++
 .../{lv_obj_style_dec.h => lv_obj_style.h}    |  295 +-
 src/lv_font/lv_font.h                         |    2 +-
 src/lv_themes/lv_theme.c                      |  170 +-
 src/lv_themes/lv_theme_empty.c                |    2 +-
 src/lv_themes/lv_theme_material.c             |  162 +-
 src/lv_themes/lv_theme_mono.c                 |  162 +-
 src/lv_themes/lv_theme_template.c             |  172 +-
 src/lv_widgets/lv_label.c                     |    2 +-
 22 files changed, 3526 insertions(+), 3413 deletions(-)
 rename src/lv_core/{lv_scroll.c => lv_indev_scroll.c} (98%)
 rename src/lv_core/{lv_scroll.h => lv_indev_scroll.h} (88%)
 create mode 100644 src/lv_core/lv_obj_pos.c
 create mode 100644 src/lv_core/lv_obj_pos.h
 create mode 100644 src/lv_core/lv_obj_scroll.c
 create mode 100644 src/lv_core/lv_obj_scroll.h
 create mode 100644 src/lv_core/lv_obj_style.c
 rename src/lv_core/{lv_obj_style_dec.h => lv_obj_style.h} (58%)

diff --git a/src/lv_core/lv_disp.c b/src/lv_core/lv_disp.c
index 6cf6283ef..14f480dd0 100644
--- a/src/lv_core/lv_disp.c
+++ b/src/lv_core/lv_disp.c
@@ -230,8 +230,8 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
     /*Be sure both screens are in a normal position*/
     lv_obj_set_pos(new_scr, 0, 0);
     lv_obj_set_pos(lv_scr_act(), 0, 0);
-    lv_style_remove_prop(lv_obj_get_local_style(new_scr, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
-    lv_style_remove_prop(lv_obj_get_local_style(lv_scr_act(), LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+    lv_style_remove_prop(_lv_obj_get_local_style(new_scr, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+    lv_style_remove_prop(_lv_obj_get_local_style(lv_scr_act(), LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
 
     lv_anim_t a_new;
     lv_anim_init(&a_new);
@@ -395,6 +395,6 @@ static void scr_anim_ready(lv_anim_t * a)
 
     if(d->prev_scr && d->del_prev) lv_obj_del(d->prev_scr);
     d->prev_scr = NULL;
-    lv_style_remove_prop(lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+    lv_style_remove_prop(_lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
 }
 #endif
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index a7a08a588..3c8fcd820 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -98,6 +98,166 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
     return false;
 }
 
+
+
+static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, uint32_t * child_id_ext, lv_point_t * grid_abs)
+{
+    if(_lv_obj_is_grid_item(item) == false) return;
+
+    uint32_t col_pos;
+    uint32_t col_span;
+    uint32_t row_pos;
+    uint32_t row_span;
+
+    if(cont->grid->row_dsc && cont->grid->col_dsc) {
+        col_pos = _GRID_GET_CELL_POS(item->x_set);
+        col_span = _GRID_GET_CELL_SPAN(item->x_set);
+        row_pos = _GRID_GET_CELL_POS(item->y_set);
+        row_span = _GRID_GET_CELL_SPAN(item->y_set);
+    } else {
+        col_span = 1;
+        row_span = 1;
+
+        uint32_t child_id = 0;
+        if(child_id_ext) child_id = *child_id_ext;
+        else {
+            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+
+            while(child) {
+                if(child == item) break;
+                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+                    child_id++;
+                }
+                child = lv_obj_get_child_back(cont, child);
+            }
+        }
+
+        if(cont->grid->row_dsc == NULL) {
+            col_pos = child_id % cont->grid->col_dsc_len;
+            row_pos = child_id / cont->grid->col_dsc_len;
+        } else {
+            col_pos = child_id / cont->grid->row_dsc_len;
+            row_pos = child_id % cont->grid->row_dsc_len;
+        }
+    }
+
+    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
+    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
+
+    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
+    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
+
+    lv_coord_t x;
+    lv_coord_t y;
+    lv_coord_t w = lv_obj_get_width(item);
+    lv_coord_t h = lv_obj_get_height(item);
+
+    switch(x_flag) {
+        case LV_GRID_START:
+            x = calc->col_dsc[col_pos];
+            break;
+        case LV_GRID_STRETCH:
+            x = calc->col_dsc[col_pos];
+            w = col_w;
+            item->w_set = LV_SIZE_STRETCH;
+            break;
+        case LV_GRID_CENTER:
+            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
+            break;
+        case LV_GRID_END:
+            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
+            break;
+    }
+
+    switch(y_flag) {
+        case LV_GRID_START:
+            y = calc->row_dsc[row_pos];
+            break;
+        case LV_GRID_STRETCH:
+            y = calc->row_dsc[row_pos];
+            item->h_set = LV_SIZE_STRETCH;
+            h = row_h;
+            break;
+        case LV_GRID_CENTER:
+            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
+            break;
+        case LV_GRID_END:
+            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
+            break;
+    }
+
+    /*Set a new size if required*/
+    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
+        lv_area_t old_coords;
+        lv_area_copy(&old_coords, &item->coords);
+        lv_obj_invalidate(item);
+        lv_area_set_width(&item->coords, w);
+        lv_area_set_height(&item->coords, h);
+        lv_obj_invalidate(item);
+        item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
+
+        /* If a children is a grid container and has an FR field it also needs to be updated
+         * because the FR cell size will change with child size change. */
+        lv_obj_t * child = lv_obj_get_child(item, NULL);
+        while(child) {
+            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
+                lv_grid_full_refr(child);
+            }
+            child = lv_obj_get_child(item, child);
+        }
+    }
+    bool moved = true;
+    if(grid_abs) {
+        if(grid_abs->x + x == item->coords.x1 && grid_abs->y + y == item->coords.y1) moved = false;
+    }
+
+    if(moved) _lv_obj_move_to(item, x, y, false);
+}
+
+void lv_grid_full_refr(lv_obj_t * cont)
+{
+    /*Calculate the grid*/
+    if(cont->grid == NULL) return;
+    _lv_grid_calc_t calc;
+    grid_calc(cont, &calc);
+
+    /* Calculate the grids absolute x and y coordinates.
+     * It will be used as helper during item repositioning to avoid calculating this value for every children*/
+    lv_point_t grid_abs;
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_top = lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN);
+    grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
+    grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
+
+    uint32_t child_id = 0;
+    lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
+    while(item) {
+        if(_GRID_IS_CELL(item->x_set) && _GRID_IS_CELL(item->y_set)) {
+            _grid_item_repos(cont, item, &calc, &child_id, &grid_abs);
+            child_id++;
+        }
+        item = lv_obj_get_child_back(cont, item);
+    }
+    grid_calc_free(&calc);
+
+    if(cont->w_set == LV_SIZE_AUTO || cont->h_set == LV_SIZE_AUTO) {
+        lv_obj_set_size(cont, cont->w_set, cont->h_set);
+    }
+}
+
+void lv_grid_item_refr_pos(lv_obj_t * item)
+{
+    /*Calculate the grid*/
+    lv_obj_t * cont = lv_obj_get_parent(item);
+    if(cont->grid == NULL) return;
+    _lv_grid_calc_t calc;
+    grid_calc(cont, &calc);
+
+    _grid_item_repos(cont, item, &calc, NULL, NULL);
+
+    grid_calc_free(&calc);
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index b64576072..846ca718a 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -75,6 +75,7 @@ extern "C" {
 
 /* Can't include lv_obj.h because it includes this header file */
 struct _lv_obj_t;
+typedef struct _lv_obj_t lv_obj_t;
 
 /**
  * Describe how to flow LV_GRID_POS_AUTO elements
@@ -120,6 +121,12 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
 
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 
+void lv_grid_full_refr(lv_obj_t * cont);
+
+void lv_grid_item_refr_pos(lv_obj_t * item);
+
+bool _lv_obj_is_grid_item(lv_obj_t * obj);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 5f3157b2c..50ad967df 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -9,11 +9,11 @@
 #include "lv_indev.h"
 #include "lv_disp.h"
 #include "lv_obj.h"
-#include "lv_scroll.h"
+#include "lv_indev_scroll.h"
+#include "lv_group.h"
+#include "lv_refr.h"
 
 #include "../lv_hal/lv_hal_tick.h"
-#include "../lv_core/lv_group.h"
-#include "../lv_core/lv_refr.h"
 #include "../lv_misc/lv_task.h"
 #include "../lv_misc/lv_math.h"
 
diff --git a/src/lv_core/lv_indev.h b/src/lv_core/lv_indev.h
index 2b6c69161..53c5b8451 100644
--- a/src/lv_core/lv_indev.h
+++ b/src/lv_core/lv_indev.h
@@ -15,7 +15,7 @@ extern "C" {
  *********************/
 #include "lv_obj.h"
 #include "../lv_hal/lv_hal_indev.h"
-#include "../lv_core/lv_group.h"
+#include "lv_group.h"
 
 /*********************
  *      DEFINES
diff --git a/src/lv_core/lv_scroll.c b/src/lv_core/lv_indev_scroll.c
similarity index 98%
rename from src/lv_core/lv_scroll.c
rename to src/lv_core/lv_indev_scroll.c
index 9fc7e5155..fa0fcfc89 100644
--- a/src/lv_core/lv_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -6,8 +6,8 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_scroll.h"
 #include "lv_indev.h"
+#include "lv_indev_scroll.h"
 
 /*********************
  *      DEFINES
@@ -228,7 +228,7 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
         /*Respect the scroll limit area*/
         scroll_limit_diff(proc, &diff_x, &diff_y);
 
-        lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
+        _lv_obj_scroll_by_raw(scroll_obj, diff_x, diff_y);
         proc->types.pointer.scroll_sum.x += diff_x;
         proc->types.pointer.scroll_sum.y += diff_y;
     }
@@ -265,7 +265,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
                 proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
             }
 
-            lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
+            _lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
         }
         /*With snapping find the nearest snap point and scroll there*/
         else {
@@ -291,7 +291,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
                 proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
             }
 
-            lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
+            _lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
         }
         /*With snapping find the nearest snap point and scroll there*/
         else {
diff --git a/src/lv_core/lv_scroll.h b/src/lv_core/lv_indev_scroll.h
similarity index 88%
rename from src/lv_core/lv_scroll.h
rename to src/lv_core/lv_indev_scroll.h
index 293efd592..b43d608d5 100644
--- a/src/lv_core/lv_scroll.h
+++ b/src/lv_core/lv_indev_scroll.h
@@ -1,10 +1,10 @@
 /**
- * @file lv_scroll.h
+ * @file lv_indev_scroll.h
  *
  */
 
-#ifndef LV_SCROLL_H
-#define LV_SCROLL_H
+#ifndef LV_INDEV_SCROLL_H
+#define LV_INDEV_SCROLL_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,4 +48,4 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc);
 } /* extern "C" */
 #endif
 
-#endif /*LV_SCROLL_H*/
+#endif /*LV_INDEV_SCROLL_H*/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 780ac26b5..caeecc90d 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -49,9 +49,6 @@
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
 #define SCROLLBAR_MIN_SIZE (LV_DPX(10))
-#define SCROLL_ANIM_TIME_MIN 100    /*ms*/
-#define SCROLL_ANIM_TIME_MAX 300    /*ms*/
-
 #define GRID_DEBUG  1 /*Draw rectangles on grid cells*/
 
 /**********************
@@ -63,58 +60,19 @@ typedef struct _lv_event_temp_data {
     struct _lv_event_temp_data * prev;
 } lv_event_temp_data_t;
 
-typedef struct {
-    lv_obj_t * obj;
-    lv_style_property_t prop;
-    uint8_t part;
-    union {
-        lv_color_t _color;
-        lv_style_int_t _int;
-        lv_opa_t _opa;
-        const void * _ptr;
-    } start_value;
-    union {
-        lv_color_t _color;
-        lv_style_int_t _int;
-        lv_opa_t _opa;
-        const void * _ptr;
-    } end_value;
-} lv_style_trans_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
 static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param);
-static void refresh_children_position(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff);
-static void report_style_mod_core(void * style_p, lv_obj_t * obj);
-static void refresh_children_style(lv_obj_t * obj);
-static void base_dir_refr_children(lv_obj_t * obj);
-static void obj_align_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, bool x_set, bool y_set,
-                           lv_coord_t x_ofs, lv_coord_t y_ofs);
-static void obj_align_mid_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,  bool x_set, bool y_set,
-                               lv_coord_t x_ofs, lv_coord_t y_ofs);
-#if LV_USE_ANIMATION
-static lv_style_trans_t * trans_create(lv_obj_t * obj, lv_style_property_t prop, uint8_t part, lv_state_t prev_state,
-                                       lv_state_t new_state);
-static void trans_del(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_trans_t * tr_limit);
-static void trans_anim_cb(lv_style_trans_t * tr, lv_anim_value_t v);
-static void trans_anim_start_cb(lv_anim_t * a);
-static void trans_anim_ready_cb(lv_anim_t * a);
-static void opa_scale_anim(lv_obj_t * obj, lv_anim_value_t v);
-static void fade_in_anim_ready(lv_anim_t * a);
-static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v);
-static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v);
-#endif
 static void lv_event_mark_deleted(lv_obj_t * obj);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
 static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
 static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area);
-static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop);
-static void update_style_cache_children(lv_obj_t * obj);
-static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+static void base_dir_refr_children(lv_obj_t * obj);
 
 /**********************
  *  STATIC VARIABLES
@@ -165,7 +123,7 @@ void lv_init(void)
     lv_gpu_stm32_dma2d_init();
 #endif
 
-    _lv_ll_init(&LV_GC_ROOT(_lv_obj_style_trans_ll), sizeof(lv_style_trans_t));
+    _lv_obj_style_init();
 
     _lv_ll_init(&LV_GC_ROOT(_lv_disp_ll), sizeof(lv_disp_t));
     _lv_ll_init(&LV_GC_ROOT(_lv_indev_ll), sizeof(lv_indev_t));
@@ -697,706 +655,7 @@ void lv_obj_move_background(lv_obj_t * obj)
  * Coordinate set
  * ------------------*/
 
-static void move_obj_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent)
-{
-    /*Convert x and y to absolute coordinates*/
-    lv_obj_t * parent = obj->parent;
 
-    if(parent) {
-        lv_coord_t pad_left = lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
-        lv_coord_t pad_top = lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
-
-        x += pad_left + parent->coords.x1 - lv_obj_get_scroll_left(parent);
-        y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
-    } else {
-        /*If no parent then it's screen but screen can't be on a grid*/
-        if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
-            obj->x_set = 0;
-            obj->y_set = 0;
-            x = 0;
-            y = 0;
-        }
-    }
-
-    /*Calculate and set the movement*/
-    lv_point_t diff;
-    diff.x = x - obj->coords.x1;
-    diff.y = y - obj->coords.y1;
-
-    /* Do nothing if the position is not changed */
-    /* It is very important else recursive positioning can
-     * occur without position change*/
-    if(diff.x == 0 && diff.y == 0) return;
-
-    /*Invalidate the original area*/
-    lv_obj_invalidate(obj);
-
-    /*Save the original coordinates*/
-    lv_area_t ori;
-    lv_obj_get_coords(obj, &ori);
-
-    obj->coords.x1 += diff.x;
-    obj->coords.y1 += diff.y;
-    obj->coords.x2 += diff.x;
-    obj->coords.y2 += diff.y;
-
-    refresh_children_position(obj, diff.x, diff.y);
-
-    /*Inform the object about its new coordinates*/
-    obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
-
-    /*Send a signal to the parent too*/
-    if(parent && notify_parent) parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
-
-    /*Invalidate the new area*/
-    lv_obj_invalidate(obj);
-}
-
-
-static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
-{
-    /* Do nothing if the size is not changed */
-    /* It is very important else recursive resizing can
-     * occur without size change*/
-    if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
-        return false;
-    }
-    /*Invalidate the original area*/
-    lv_obj_invalidate(obj);
-
-    /*Save the original coordinates*/
-    lv_area_t ori;
-    lv_obj_get_coords(obj, &ori);
-
-    /*Set the length and height*/
-    obj->coords.y2 = obj->coords.y1 + h - 1;
-    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
-        obj->coords.x1 = obj->coords.x2 - w + 1;
-    }
-    else {
-        obj->coords.x2 = obj->coords.x1 + w - 1;
-    }
-
-    /*Send a signal to the object with its new coordinates*/
-    obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
-
-    /*Send a signal to the parent too*/
-    lv_obj_t * par = lv_obj_get_parent(obj);
-    if(par != NULL) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
-
-    /*Invalidate the new area*/
-    lv_obj_invalidate(obj);
-    return true;
-}
-
-bool lv_obj_is_grid_item(lv_obj_t * obj);
-static void lv_grid_full_refr(lv_obj_t * cont);
-
-static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, uint32_t * child_id_ext, lv_point_t * grid_abs)
-{
-    if(lv_obj_is_grid_item(item) == false) return;
-
-    uint32_t col_pos;
-    uint32_t col_span;
-    uint32_t row_pos;
-    uint32_t row_span;
-
-    if(cont->grid->row_dsc && cont->grid->col_dsc) {
-        col_pos = _GRID_GET_CELL_POS(item->x_set);
-        col_span = _GRID_GET_CELL_SPAN(item->x_set);
-        row_pos = _GRID_GET_CELL_POS(item->y_set);
-        row_span = _GRID_GET_CELL_SPAN(item->y_set);
-    } else {
-        col_span = 1;
-        row_span = 1;
-
-        uint32_t child_id = 0;
-        if(child_id_ext) child_id = *child_id_ext;
-        else {
-            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
-
-            while(child) {
-                if(child == item) break;
-                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-                    child_id++;
-                }
-                child = lv_obj_get_child_back(cont, child);
-            }
-        }
-
-        if(cont->grid->row_dsc == NULL) {
-            col_pos = child_id % cont->grid->col_dsc_len;
-            row_pos = child_id / cont->grid->col_dsc_len;
-        } else {
-            col_pos = child_id / cont->grid->row_dsc_len;
-            row_pos = child_id % cont->grid->row_dsc_len;
-        }
-    }
-
-    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
-    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
-
-    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
-    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
-
-    lv_coord_t x;
-    lv_coord_t y;
-    lv_coord_t w = lv_obj_get_width(item);
-    lv_coord_t h = lv_obj_get_height(item);
-
-    switch(x_flag) {
-        case LV_GRID_START:
-            x = calc->col_dsc[col_pos];
-            break;
-        case LV_GRID_STRETCH:
-            x = calc->col_dsc[col_pos];
-            w = col_w;
-            item->w_set = LV_SIZE_STRETCH;
-            break;
-        case LV_GRID_CENTER:
-            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
-            break;
-        case LV_GRID_END:
-            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
-            break;
-    }
-
-    switch(y_flag) {
-        case LV_GRID_START:
-            y = calc->row_dsc[row_pos];
-            break;
-        case LV_GRID_STRETCH:
-            y = calc->row_dsc[row_pos];
-            item->h_set = LV_SIZE_STRETCH;
-            h = row_h;
-            break;
-        case LV_GRID_CENTER:
-            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
-            break;
-        case LV_GRID_END:
-            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
-            break;
-    }
-
-    /*Set a new size if required*/
-    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
-        lv_area_t old_coords;
-        lv_area_copy(&old_coords, &item->coords);
-        lv_obj_invalidate(item);
-        lv_area_set_width(&item->coords, w);
-        lv_area_set_height(&item->coords, h);
-        lv_obj_invalidate(item);
-        item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
-
-        /* If a children is a grid container and has an FR field it also needs to be updated
-         * because the FR cell size will change with child size change. */
-        lv_obj_t * child = lv_obj_get_child(item, NULL);
-        while(child) {
-            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
-                lv_grid_full_refr(child);
-            }
-            child = lv_obj_get_child(item, child);
-        }
-    }
-    bool moved = true;
-    if(grid_abs) {
-        if(grid_abs->x + x == item->coords.x1 && grid_abs->y + y == item->coords.y1) moved = false;
-    }
-
-    if(moved) move_obj_to(item, x, y, false);
-}
-
-static void lv_grid_full_refr(lv_obj_t * cont)
-{
-    /*Calculate the grid*/
-    if(cont->grid == NULL) return;
-    _lv_grid_calc_t calc;
-    grid_calc(cont, &calc);
-
-    /* Calculate the grids absolute x and y coordinates.
-     * It will be used as helper during item repositioning to avoid calculating this value for every children*/
-    lv_point_t grid_abs;
-    lv_coord_t pad_left = lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN);
-    lv_coord_t pad_top = lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN);
-    grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
-    grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
-
-    uint32_t child_id = 0;
-    lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
-    while(item) {
-        if(_GRID_IS_CELL(item->x_set) && _GRID_IS_CELL(item->y_set)) {
-            _grid_item_repos(cont, item, &calc, &child_id, &grid_abs);
-            child_id++;
-        }
-        item = lv_obj_get_child_back(cont, item);
-    }
-    grid_calc_free(&calc);
-
-    if(cont->w_set == LV_SIZE_AUTO || cont->h_set == LV_SIZE_AUTO) {
-        lv_obj_set_size(cont, cont->w_set, cont->h_set);
-    }
-}
-
-static void lv_grid_item_refr_pos(lv_obj_t * item)
-{
-    /*Calculate the grid*/
-    lv_obj_t * cont = lv_obj_get_parent(item);
-    if(cont->grid == NULL) return;
-    _lv_grid_calc_t calc;
-    grid_calc(cont, &calc);
-
-    _grid_item_repos(cont, item, &calc, NULL, NULL);
-
-    grid_calc_free(&calc);
-}
-
-bool lv_obj_is_grid_item(lv_obj_t * obj)
-{
-    lv_obj_t * cont = lv_obj_get_parent(obj);
-    if(cont == NULL) return false;
-    if(cont->grid == NULL) return false;
-    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->y_set)) return true;
-    return false;
-}
-
-/**
- * Set relative the position of an object (relative to the parent)
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->x_set = x;
-    obj->y_set = y;
-
-    bool gi = lv_obj_is_grid_item(obj);
-
-    /*For consistency set the size to stretched if the objects is stretched on the grid*/
-    if(gi) {
-        if(_GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
-        if(_GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
-    }
-
-    /*If not grid item but has grid position set the position to 0*/
-    if(!gi) {
-        if(_GRID_IS_CELL(x)) {
-            obj->x_set = 0;
-            x = 0;
-        }
-        if(_GRID_IS_CELL(y)) {
-            obj->y_set = 0;
-            y = 0;
-        }
-    }
-
-    /*If the object is on a grid item let the grid to position it. */
-    if(gi) {
-        lv_area_t old_area;
-        lv_area_copy(&old_area, &obj->coords);
-        lv_grid_item_refr_pos(obj);
-
-        lv_obj_t * cont = lv_obj_get_parent(obj);
-
-        /*If the item was moved and grid is implicit in the changed direction refresh the whole grid.*/
-        if((cont->grid->col_dsc == NULL && (old_area.x1 != obj->coords.x1 || old_area.x2 != obj->coords.x2)) ||
-           (cont->grid->row_dsc == NULL && (old_area.y1 != obj->coords.y1 || old_area.y2 != obj->coords.y2)))
-        {
-            lv_grid_full_refr(cont);
-        }
-    } else {
-        move_obj_to(obj, x, y, true);
-    }
-}
-
-/**
- * Set the x coordinate of a object
- * @param obj pointer to an object
- * @param x new distance from the left side from the parent
- */
-void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
-}
-
-/**
- * Set the y coordinate of a object
- * @param obj pointer to an object
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
-}
-
-void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
-{
-    if(!w && !h) return;
-
-//    static uint32_t cnt = 0;
-//    printf("auto_size: %d\n", cnt);
-//    cnt++;
-
-    /*If no other effect the auto-size of zero by default*/
-    if(w) *w = 0;
-    if(h) *h = 0;
-
-    /*Get the grid size of the object has a defined grid*/
-    lv_coord_t grid_w = 0;
-    lv_coord_t grid_h = 0;
-    if(obj->grid) {
-        _lv_grid_calc_t calc;
-        grid_calc(obj, &calc);
-        grid_w = calc.col_dsc[calc.col_dsc_len - 1] + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-        grid_h = calc.row_dsc[calc.row_dsc_len - 1] + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);;
-        grid_calc_free(&calc);
-    }
-
-    /*Get the children's most right and bottom position*/
-    lv_coord_t children_w = 0;
-    lv_coord_t children_h = 0;
-    if(w) {
-        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
-        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
-        children_w = lv_obj_get_width(obj) + scroll_right;
-    }
-
-    if(h) {
-        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
-        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
-        children_h = lv_obj_get_height(obj) + scroll_bottom;
-    }
-
-
-    /*auto_size = max(gird_size, children_size)*/
-    if(w) *w = LV_MATH_MAX(children_w, grid_w);
-    if(h) *h = LV_MATH_MAX(children_h, grid_h);
-}
-
-/**
- * Set the size of an object
- * @param obj pointer to an object
- * @param w new width
- * @param h new height
- */
-void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    bool gi = lv_obj_is_grid_item(obj);
-    bool x_stretch = false;
-    bool y_stretch = false;
-
-    if(gi) {
-        x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
-        y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
-        if(x_stretch) w = LV_SIZE_STRETCH;
-        if(y_stretch) h = LV_SIZE_STRETCH;
-    }
-
-    obj->w_set = w;
-    obj->h_set = h;
-
-    /*If both streched it was alraedy managed by the grid*/
-    if(x_stretch && y_stretch) return;
-
-    if(x_stretch) w = lv_obj_get_width(obj);
-    if(y_stretch) h = lv_obj_get_height(obj);
-
-    /*Calculate the required auto sizes*/
-    bool x_auto = obj->w_set == LV_SIZE_AUTO ? true : false;
-    bool y_auto = obj->h_set == LV_SIZE_AUTO ? true : false;
-
-    lv_coord_t auto_w;
-    lv_coord_t auto_h;
-    if(x_auto && y_auto) {
-        _lv_obj_calc_auto_size(obj, &auto_w, &auto_h);
-        w = auto_w;
-        h = auto_h;
-    }
-    else if(x_auto) {
-        _lv_obj_calc_auto_size(obj, &auto_w, NULL);
-        w = auto_w;
-    }
-    else if(y_auto) {
-        _lv_obj_calc_auto_size(obj, NULL, &auto_h);
-        h = auto_h;
-    }
-
-    refr_size(obj, w, h);
-}
-
-/**
- * Set the width of an object
- * @param obj pointer to an object
- * @param w new width
- */
-void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_size(obj, w, lv_obj_get_height(obj));
-}
-
-/**
- * Set the height of an object
- * @param obj pointer to an object
- * @param h new height
- */
-void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_obj_set_size(obj, lv_obj_get_width(obj), h);
-}
-
-/**
- * Set the width reduced by the left and right padding.
- * @param obj pointer to an object
- * @param w the width without paddings
- */
-void lv_obj_set_width_fit(lv_obj_t * obj, lv_coord_t w)
-{
-    lv_style_int_t pleft = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t pright = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-
-    lv_obj_set_width(obj, w - pleft - pright);
-}
-
-/**
- * Set the height reduced by the top and bottom padding.
- * @param obj pointer to an object
- * @param h the height without paddings
- */
-void lv_obj_set_height_fit(lv_obj_t * obj, lv_coord_t h)
-{
-    lv_style_int_t ptop = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t pbottom = lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-
-    lv_obj_set_height(obj, h - ptop - pbottom);
-}
-
-/**
- * Set the width of an object by taking the left and right margin into account.
- * The object width will be `obj_w = w - margin_left - margin_right`
- * @param obj pointer to an object
- * @param w new height including margins
- */
-void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w)
-{
-    lv_style_int_t mleft = lv_obj_get_style_margin_left(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t mright = lv_obj_get_style_margin_right(obj, LV_OBJ_PART_MAIN);
-
-    lv_obj_set_width(obj, w - mleft - mright);
-}
-
-/**
- * Set the height of an object by taking the top and bottom margin into account.
- * The object height will be `obj_h = h - margin_top - margin_bottom`
- * @param obj pointer to an object
- * @param h new height including margins
- */
-void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h)
-{
-    lv_style_int_t mtop = lv_obj_get_style_margin_top(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(obj, LV_OBJ_PART_MAIN);
-
-    lv_obj_set_height(obj, h - mtop - mbottom);
-}
-
-/**
- * Align an object to an other object.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(base == NULL) base = lv_obj_get_parent(obj);
-
-    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
-
-    obj_align_core(obj, base, align, true, true, x_ofs, y_ofs);
-}
-
-/**
- * Moves all children with horizontally or vertically.
- * It doesn't take into account any limits so any values are possible
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
-void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
-{
-    obj->scroll.x += x;
-    obj->scroll.y += y;
-
-    refresh_children_position(obj, x, y);
-    lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
-    if(res != LV_RES_OK) return;
-    lv_obj_invalidate(obj);
-}
-/**
- * Moves all children with horizontally or vertically.
- * Limits the scroll to the bounding box of the children.
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
-void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
-{
-
-    if(x == 0 && y == 0) return;
-
-    if(anim_en == LV_ANIM_ON) {
-        lv_disp_t * d = lv_obj_get_disp(obj);
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, obj);
-
-        lv_anim_path_t path;
-        lv_anim_path_init(&path);
-        lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
-
-        if(x) {
-            uint32_t t = lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 3) >> 2, 0, x);
-            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
-            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
-            lv_anim_set_time(&a, t);
-            lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
-            lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
-            lv_anim_set_path(&a, &path);
-            lv_anim_start(&a);
-        }
-
-        if(y) {
-            uint32_t t = lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y);
-            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
-            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
-            lv_anim_set_time(&a, t);
-            lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
-            lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
-            lv_anim_set_path(&a, &path);
-            lv_anim_start(&a);
-        }
-    } else {
-        lv_obj_scroll_by_raw(obj, x, y);
-    }
-}
-
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- * @param y the y coordinate to scroll to
- */
-void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
-{
-
-}
-
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- */
-void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
-{
-    lv_obj_scroll_by(obj, -x - obj->scroll.x, 0, anim_en);
-}
-
-/**
- * Scroll the a given y coordinate to the top side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param y the y coordinate to scroll to
- */
-void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
-{
-    lv_obj_scroll_by(obj, 0,  -y - obj->scroll.y, anim_en);
-}
-
-
-/**
- * Return the height of the area above the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
-{
-    return -obj->scroll.y;
-}
-
-/**
- * Return the height of the area below the parent.
- * That is the number of pixels the object can be scrolled up.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_coord_t y2 = LV_COORD_MIN;
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child == NULL) return 0;
-
-    while(child) {
-        y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
-        child = lv_obj_get_child(obj, child);
-    }
-
-    return y2 - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-}
-
-/**
- * Return the weight of the area on the left the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
-{
-    return -obj->scroll.x;
-}
-
-/**
- * Return the width of the area below the object.
- * That is the number of pixels the object can be scrolled left.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_coord_t x2 = LV_COORD_MIN;
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child == NULL) return 0;
-
-    while(child) {
-        x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
-        child = lv_obj_get_child(obj, child);
-    }
-
-    return x2 - obj->coords.x2  + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-}
 
 /**
  * Set the size of an extended clickable area
@@ -1433,317 +692,6 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
  * Appearance set
  *--------------------*/
 
-/**
- * Add a new style to the style list of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param style pointer to a style to add (Only its pointer will be saved)
- */
-void lv_obj_add_style(lv_obj_t * obj, uint8_t part, lv_style_t * style)
-{
-    if(style == NULL) return;
-
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    if(style_dsc == NULL) {
-        LV_LOG_WARN("Can't find style with part: %d", part);
-        return;
-    }
-
-    _lv_style_list_add_style(style_dsc, style);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, 0xFF, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
-}
-
-/**
- * Remove a style from the style list of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param style pointer to a style to remove
- */
-void lv_obj_remove_style(lv_obj_t * obj, uint8_t part, lv_style_t * style)
-{
-    if(style == NULL) return;
-
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    if(style_dsc == NULL) {
-        LV_LOG_WARN("Can't find style with part: %d", part);
-        return;
-    }
-
-    _lv_style_list_remove_style(style_dsc, style);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, 0xFF, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
-}
-
-/**
- * Reset a style to the default (empty) state.
- * Release all used memories and cancel pending related transitions.
- * Typically used in `LV_SIGN_CLEAN_UP.
- * @param obj pointer to an object
- * @param part the part of the object which style list should be reseted.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- */
-void lv_obj_clean_style_list(lv_obj_t * obj, uint8_t part)
-{
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    if(style_dsc == NULL) {
-        LV_LOG_WARN("lv_obj_clean_style_list: can't find style with `part`");
-        return;
-    }
-
-    _lv_style_list_reset(style_dsc);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, 0xFF, NULL);
-#endif
-}
-
-/**
- * Reset a style to the default (empty) state.
- * Release all used memories and cancel pending related transitions.
- * Also notifies the object about the style change.
- * @param obj pointer to an object
- * @param part the part of the object which style list should be reseted.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- */
-void lv_obj_reset_style_list(lv_obj_t * obj, uint8_t part)
-{
-    lv_obj_clean_style_list(obj, part);
-
-    lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
-}
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has integer type
- */
-void _lv_obj_set_style_local_int(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_int_t value)
-{
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    _lv_style_list_set_local_int(style_dsc, prop, value);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, prop, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
-}
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has color type
- */
-void _lv_obj_set_style_local_color(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_color_t color)
-{
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    _lv_style_list_set_local_color(style_dsc, prop, color);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, prop, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
-}
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has opacity type
- */
-void _lv_obj_set_style_local_opa(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_opa_t opa)
-{
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    _lv_style_list_set_local_opa(style_dsc, prop, opa);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, prop, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
-}
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param value the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has pointer type
- */
-void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, const void * value)
-{
-    lv_style_list_t * style_dsc = lv_obj_get_style_list(obj, part);
-    _lv_style_list_set_local_ptr(style_dsc, prop, value);
-#if LV_USE_ANIMATION
-    trans_del(obj, part, prop, NULL);
-#endif
-    lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
-}
-
-/**
- * Remove a local style property from a part of an object with a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be removed.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @note shouldn't be used directly. Use the specific property remove functions instead.
- *       For example: `lv_obj_style_remove_border_opa()`
- * @return true: the property was found and removed; false: the property was not found
- */
-bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-    lv_style_t * style = lv_obj_get_local_style(obj, part);
-    if(style) return lv_style_remove_prop(style, prop);
-    else return false;
-}
-
-/**
- * Notify an object (and its children) about its style is modified
- * @param obj pointer to an object
- * @param part the part of the object which style property should be refreshed.
- * @param prop `LV_STYLE_PROP_ALL` or an `LV_STYLE_...` property. It is used to optimize what needs to be refreshed.
- */
-void lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    invalidate_style_cache(obj, part, prop);
-
-    /*If a real style refresh is required*/
-    bool real_refr = false;
-    switch(prop) {
-        case LV_STYLE_PROP_ALL:
-        case LV_STYLE_CLIP_CORNER:
-        case LV_STYLE_SIZE:
-        case LV_STYLE_TRANSFORM_WIDTH:
-        case LV_STYLE_TRANSFORM_HEIGHT:
-        case LV_STYLE_TRANSFORM_ANGLE:
-        case LV_STYLE_TRANSFORM_ZOOM:
-        case LV_STYLE_PAD_TOP:
-        case LV_STYLE_PAD_BOTTOM:
-        case LV_STYLE_PAD_LEFT:
-        case LV_STYLE_PAD_RIGHT:
-        case LV_STYLE_PAD_INNER:
-        case LV_STYLE_MARGIN_TOP:
-        case LV_STYLE_MARGIN_BOTTOM:
-        case LV_STYLE_MARGIN_LEFT:
-        case LV_STYLE_MARGIN_RIGHT:
-        case LV_STYLE_OUTLINE_WIDTH:
-        case LV_STYLE_OUTLINE_PAD:
-        case LV_STYLE_OUTLINE_OPA:
-        case LV_STYLE_SHADOW_WIDTH:
-        case LV_STYLE_SHADOW_OPA:
-        case LV_STYLE_SHADOW_OFS_X:
-        case LV_STYLE_SHADOW_OFS_Y:
-        case LV_STYLE_SHADOW_SPREAD:
-        case LV_STYLE_VALUE_LETTER_SPACE:
-        case LV_STYLE_VALUE_LINE_SPACE:
-        case LV_STYLE_VALUE_OFS_X:
-        case LV_STYLE_VALUE_OFS_Y:
-        case LV_STYLE_VALUE_ALIGN:
-        case LV_STYLE_VALUE_STR:
-        case LV_STYLE_VALUE_FONT:
-        case LV_STYLE_VALUE_OPA:
-        case LV_STYLE_TEXT_LETTER_SPACE:
-        case LV_STYLE_TEXT_LINE_SPACE:
-        case LV_STYLE_TEXT_FONT:
-        case LV_STYLE_LINE_WIDTH:
-            real_refr = true;
-            break;
-        default:
-            real_refr = false;
-    }
-
-    if(real_refr) {
-        lv_obj_invalidate(obj);
-        obj->signal_cb(obj, LV_SIGNAL_STYLE_CHG, NULL);
-
-        switch(prop) {
-            case LV_STYLE_PROP_ALL:
-            case LV_STYLE_MARGIN_TOP:
-            case LV_STYLE_MARGIN_BOTTOM:
-            case LV_STYLE_MARGIN_LEFT:
-            case LV_STYLE_MARGIN_RIGHT:
-                if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, obj);
-                break;
-        }
-
-        lv_obj_invalidate(obj);
-
-        /*Send style change signals*/
-        if(prop == LV_STYLE_PROP_ALL || (prop & LV_STYLE_INHERIT_MASK)) refresh_children_style(obj);
-    }
-    else {
-        lv_obj_invalidate(obj);
-    }
-}
-
-/**
- * Notify all object if a style is modified
- * @param style pointer to a style. Only the objects with this style will be notified
- *               (NULL to notify all objects)
- */
-void lv_obj_report_style_mod(lv_style_t * style)
-{
-    lv_disp_t * d = lv_disp_get_next(NULL);
-
-    while(d) {
-        lv_obj_t * i;
-        _LV_LL_READ(d->scr_ll, i) {
-            report_style_mod_core(style, i);
-        }
-        d = lv_disp_get_next(d);
-    }
-}
-
-/**
- * Enable/disable the use of style cahche for an object
- * @param obj pointer to an object
- * @param dis true: disable; false: enable (re-enable)
- */
-void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
-{
-    uint8_t part;
-    for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
-        lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-        if(list == NULL) break;
-        list->ignore_cache = dis;
-    }
-    for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
-        lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-        if(list == NULL) break;
-        list->ignore_cache = dis;
-    }
-}
-
 /*-----------------
  * Attribute set
  *----------------*/
@@ -1760,19 +708,6 @@ void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en)
     obj->adv_hittest = en == false ? 0 : 1;
 }
 
-/**
- * Set how the scrollbars should behave.
- * @param obj pointer to an object
- * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
-void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    if(obj->scroll_mode == mode) return;
-    obj->scroll_mode = mode;
-    lv_obj_invalidate(obj);
-}
 
 /**
  * Set the base direction of the object
@@ -1829,14 +764,14 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
 
 #if LV_USE_ANIMATION == 0
     obj->state = new_state;
-    lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
 #else
     lv_state_t prev_state = obj->state;
     obj->state = new_state;
 
     uint8_t part;
     for(part = 0; part < _LV_OBJ_PART_REAL_LAST; part++) {
-        lv_style_list_t * style_list = lv_obj_get_style_list(obj, part);
+        lv_style_list_t * style_list = _lv_obj_get_style_list(obj, part);
         if(style_list == NULL) break;   /*No more style lists*/
         if(style_list->ignore_trans) continue;
 
@@ -1856,31 +791,11 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
             if(props[i] != 0) {
                 _lv_style_list_add_trans_style(style_list);
 
-                lv_style_trans_t * tr = trans_create(obj, props[i], part, prev_state, new_state);
-
-                /*If there is a pending anim for this property remove it*/
-                if(tr) {
-                    tr->obj = obj;
-                    tr->prop = props[i];
-                    tr->part = part;
-
-                    lv_anim_t a;
-                    lv_anim_init(&a);
-                    lv_anim_set_var(&a, tr);
-                    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)trans_anim_cb);
-                    lv_anim_set_start_cb(&a, trans_anim_start_cb);
-                    lv_anim_set_ready_cb(&a, trans_anim_ready_cb);
-                    lv_anim_set_values(&a, 0x00, 0xFF);
-                    lv_anim_set_time(&a, time);
-                    lv_anim_set_delay(&a, delay);
-                    lv_anim_set_path(&a, path);
-                    a.early_apply = 0;
-                    lv_anim_start(&a);
-                }
+                _lv_obj_create_style_transition(obj, props[i], part, prev_state, new_state, time, delay, path);
 
             }
         }
-        lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
     }
 #endif
 
@@ -1922,26 +837,6 @@ void lv_obj_clear_state(lv_obj_t * obj, lv_state_t state)
     }
 }
 
-#if LV_USE_ANIMATION
-/**
- * Finish all pending transitions on a part of an object
- * @param obj pointer to an object
- * @param part part of the object, e.g `LV_BRN_PART_MAIN` or `LV_OBJ_PART_ALL` for all parts
- */
-void lv_obj_finish_transitions(lv_obj_t * obj, uint8_t part)
-{
-    /*Animate all related transition to the end value*/
-    lv_style_trans_t * tr;
-    _LV_LL_READ_BACK(LV_GC_ROOT(_lv_obj_style_trans_ll), tr) {
-        if(tr->obj == obj && (part == tr->part || part == LV_OBJ_PART_ALL)) {
-            trans_anim_cb(tr, 255);
-        }
-    }
-
-    /*Free all related transition data*/
-    trans_del(obj, part, 0xFF, NULL);
-}
-#endif
 
 /**
  * Set a an event handler function for an object.
@@ -2305,238 +1200,6 @@ uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj)
  * Coordinate get
  *--------------------*/
 
-/**
- * Copy the coordinates of an object to an area
- * @param obj pointer to an object
- * @param cords_p pointer to an area to store the coordinates
- */
-void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * cords_p)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_area_copy(cords_p, &obj->coords);
-}
-
-/**
- * Get a bounding which includes all the the children.
- * `margin` of the children also taken into account and makes the box larger (if positive)
- * @param obj pointer to an object
- * @param coords pointer to an area to store the coordinates
- * @return LV_RES_INV: `obj` has no children and `coords` can't be set; `LV_RES_OK`: success
- */
-lv_res_t lv_obj_get_children_box(const lv_obj_t * obj, lv_area_t * coords)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    coords->x1 = LV_COORD_MAX;
-    coords->y1 = LV_COORD_MAX;
-    coords->x2 = LV_COORD_MIN;
-    coords->y2 = LV_COORD_MIN;
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child == NULL) return LV_RES_INV;
-
-    while(child) {
-        coords->x1 = LV_MATH_MIN(coords->x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
-        coords->y1 = LV_MATH_MIN(coords->y1, child->coords.y1 - lv_obj_get_style_margin_top(child, LV_OBJ_PART_MAIN));
-        coords->x2 = LV_MATH_MAX(coords->x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
-        coords->y2 = LV_MATH_MAX(coords->y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
-
-        child = lv_obj_get_child(obj, child);
-    }
-
-    return LV_RES_OK;
-}
-
-/**
- * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
- * (Without the size of the border or other extra graphical elements)
- * @param coords_p store the result area here
- */
-void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_border_side_t part = lv_obj_get_style_border_side(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t w = lv_obj_get_style_border_width(obj, LV_OBJ_PART_MAIN);
-
-    if(part & LV_BORDER_SIDE_LEFT) coords_p->x1 += w;
-
-    if(part & LV_BORDER_SIDE_RIGHT) coords_p->x2 -= w;
-
-    if(part & LV_BORDER_SIDE_TOP) coords_p->y1 += w;
-
-    if(part & LV_BORDER_SIDE_BOTTOM) coords_p->y2 -= w;
-}
-
-/**
- * Get the x coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the left side of its parent
- */
-lv_coord_t lv_obj_get_x(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_coord_t rel_x;
-    lv_obj_t * parent = lv_obj_get_parent(obj);
-    if(parent) {
-        rel_x   = obj->coords.x1 - parent->coords.x1;
-        rel_x += lv_obj_get_scroll_left(parent);
-        rel_x -= lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
-    }
-    else {
-        rel_x = obj->coords.x1;
-    }
-    return rel_x;
-}
-
-/**
- * Get the y coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the top of its parent
- */
-lv_coord_t lv_obj_get_y(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_coord_t rel_y;
-    lv_obj_t * parent = lv_obj_get_parent(obj);
-    if(parent) {
-        rel_y = obj->coords.y1 - parent->coords.y1;
-        rel_y += lv_obj_get_scroll_top(parent);
-        rel_y -= lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
-    }
-    else {
-        rel_y = obj->coords.y1;
-    }
-    return rel_y;
-}
-
-/**
- * Get the width of an object
- * @param obj pointer to an object
- * @return the width
- */
-lv_coord_t lv_obj_get_width(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return lv_area_get_width(&obj->coords);
-}
-
-/**
- * Get the height of an object
- * @param obj pointer to an object
- * @return the height
- */
-lv_coord_t lv_obj_get_height(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return lv_area_get_height(&obj->coords);
-}
-
-/**
- * Get that width reduced by the left and right padding.
- * @param obj pointer to an object
- * @return the width which still fits into the container
- */
-lv_coord_t lv_obj_get_width_fit(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-
-    return lv_obj_get_width(obj) - left - right;
-}
-
-/**
- * Get that height reduced by the top an bottom padding.
- * @param obj pointer to an object
- * @return the height which still fits into the container
- */
-lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_style_int_t top = lv_obj_get_style_pad_top((lv_obj_t *)obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t bottom =  lv_obj_get_style_pad_bottom((lv_obj_t *)obj, LV_OBJ_PART_MAIN);
-
-    return lv_obj_get_height(obj) - top - bottom;
-}
-
-/**
- * Get the height of an object by taking the top and bottom margin into account.
- * The returned height will be `obj_h + margin_top + margin_bottom`
- * @param obj pointer to an object
- * @return the height including thee margins
- */
-lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj)
-{
-    lv_style_int_t mtop = lv_obj_get_style_margin_top(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(obj, LV_OBJ_PART_MAIN);
-
-    return lv_obj_get_height(obj) + mtop + mbottom;
-}
-
-/**
- * Get the width of an object by taking the left and right margin into account.
- * The returned width will be `obj_w + margin_left + margin_right`
- * @param obj pointer to an object
- * @return the height including thee margins
- */
-lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
-{
-    lv_style_int_t mleft = lv_obj_get_style_margin_left(obj, LV_OBJ_PART_MAIN);
-    lv_style_int_t mright = lv_obj_get_style_margin_right(obj, LV_OBJ_PART_MAIN);
-
-    return lv_obj_get_width(obj) + mleft + mright;
-}
-
-/**
- * Set that width reduced by the left and right padding of the parent.
- * @param obj pointer to an object
- * @param div indicates how many columns are assumed.
- * If 1 the width will be set the the parent's width
- * If 2 only half parent width - inner padding of the parent
- * If 3 only third parent width - 2 * inner padding of the parent
- * @param span how many columns are combined
- * @return the width according to the given parameters
- */
-lv_coord_t lv_obj_get_width_grid(lv_obj_t * obj, uint8_t div, uint8_t span)
-{
-    lv_coord_t obj_w = lv_obj_get_width_fit(obj);
-    lv_style_int_t pinner = lv_obj_get_style_pad_inner(obj, LV_OBJ_PART_MAIN);
-
-    lv_coord_t r = (obj_w - (div - 1) * pinner) / div;
-
-    r = r * span + (span - 1) * pinner;
-    return r;
-}
-
-/**
- * Get that height reduced by the top and bottom padding of the parent.
- * @param obj pointer to an object
- * @param div indicates how many rows are assumed.
- * If 1 the height will be set the the parent's height
- * If 2 only half parent height - inner padding of the parent
- * If 3 only third parent height - 2 * inner padding of the parent
- * @param span how many rows are combined
- * @return the height according to the given parameters
- */
-lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span)
-{
-    lv_coord_t obj_h = lv_obj_get_height_fit(obj);
-    lv_style_int_t pinner = lv_obj_get_style_pad_inner(obj, LV_OBJ_PART_MAIN);
-
-    lv_coord_t r = (obj_h - (div - 1) * pinner) / div;
-
-    r = r * span + (span - 1) * pinner;
-    return r;
-}
-
 /**
  * Get the left padding of extended clickable area
  * @param obj pointer to an object
@@ -2629,389 +1292,12 @@ lv_coord_t lv_obj_get_ext_draw_pad(const lv_obj_t * obj)
  * Appearance get
  *---------------*/
 
-lv_style_list_t * lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part)
-{
-    if(part == LV_OBJ_PART_MAIN) return &((lv_obj_t *)obj)->style_list;
-
-    lv_get_style_info_t info;
-    info.part = part;
-    info.result = NULL;
-
-    lv_res_t res;
-    res = lv_signal_send((lv_obj_t *)obj, LV_SIGNAL_GET_STYLE, &info);
-
-    if(res != LV_RES_OK) return NULL;
-
-    return info.result;
-}
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_WIDTH`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_width()`
- * @note for performance reasons it's not checked if the property really has integer type
- */
-lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    lv_style_property_t prop_ori = prop;
-
-    lv_style_attr_t attr;
-    attr = prop_ori >> 8;
-
-    lv_style_int_t value_act;
-    lv_res_t res = LV_RES_INV;
-    const lv_obj_t * parent = obj;
-    while(parent) {
-        lv_style_list_t * list = lv_obj_get_style_list(parent, part);
-        if(!list->ignore_cache && list->style_cnt > 0) {
-            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
-
-            bool def = false;
-            switch(prop  & (~LV_STYLE_STATE_MASK)) {
-                case LV_STYLE_BG_GRAD_DIR:
-                    if(list->bg_grad_dir_none) def = true;
-                    break;
-                case LV_STYLE_CLIP_CORNER:
-                    if(list->clip_corner_off) def = true;
-                    break;
-                case LV_STYLE_TEXT_LETTER_SPACE:
-                case LV_STYLE_TEXT_LINE_SPACE:
-                    if(list->text_space_zero) def = true;
-                    break;
-                case LV_STYLE_TRANSFORM_ANGLE:
-                case LV_STYLE_TRANSFORM_WIDTH:
-                case LV_STYLE_TRANSFORM_HEIGHT:
-                case LV_STYLE_TRANSFORM_ZOOM:
-                    if(list->transform_all_zero) def = true;
-                    break;
-                case LV_STYLE_BORDER_WIDTH:
-                    if(list->border_width_zero) def = true;
-                    break;
-                case LV_STYLE_BORDER_SIDE:
-                    if(list->border_side_full) def = true;
-                    break;
-                case LV_STYLE_BORDER_POST:
-                    if(list->border_post_off) def = true;
-                    break;
-                case LV_STYLE_OUTLINE_WIDTH:
-                    if(list->outline_width_zero) def = true;
-                    break;
-                case LV_STYLE_RADIUS:
-                    if(list->radius_zero) def = true;
-                    break;
-                case LV_STYLE_SHADOW_WIDTH:
-                    if(list->shadow_width_zero) def = true;
-                    break;
-                case LV_STYLE_PAD_TOP:
-                case LV_STYLE_PAD_BOTTOM:
-                case LV_STYLE_PAD_LEFT:
-                case LV_STYLE_PAD_RIGHT:
-                    if(list->pad_all_zero) def = true;
-                    break;
-                case LV_STYLE_MARGIN_TOP:
-                case LV_STYLE_MARGIN_BOTTOM:
-                case LV_STYLE_MARGIN_LEFT:
-                case LV_STYLE_MARGIN_RIGHT:
-                    if(list->margin_all_zero) def = true;
-                    break;
-                case LV_STYLE_BG_BLEND_MODE:
-                case LV_STYLE_BORDER_BLEND_MODE:
-                case LV_STYLE_IMAGE_BLEND_MODE:
-                case LV_STYLE_LINE_BLEND_MODE:
-                case LV_STYLE_OUTLINE_BLEND_MODE:
-                case LV_STYLE_PATTERN_BLEND_MODE:
-                case LV_STYLE_SHADOW_BLEND_MODE:
-                case LV_STYLE_TEXT_BLEND_MODE:
-                case LV_STYLE_VALUE_BLEND_MODE:
-                    if(list->blend_mode_all_normal) def = true;
-                    break;
-            }
-
-            if(def) {
-                break;
-            }
-        }
-
-        lv_state_t state = lv_obj_get_state(parent, part);
-        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
-
-        res = _lv_style_list_get_int(list, prop, &value_act);
-        if(res == LV_RES_OK) return value_act;
-
-        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
-
-        /*If not found, check the `MAIN` style first*/
-        if(part != LV_OBJ_PART_MAIN) {
-            part = LV_OBJ_PART_MAIN;
-            continue;
-        }
-
-        /*Check the parent too.*/
-        parent = lv_obj_get_parent(parent);
-    }
-
-    /*Handle unset values*/
-    prop = prop & (~LV_STYLE_STATE_MASK);
-    switch(prop) {
-        case LV_STYLE_BORDER_SIDE:
-            return LV_BORDER_SIDE_FULL;
-        case LV_STYLE_SIZE:
-            return LV_DPI / 20;
-        case LV_STYLE_SCALE_WIDTH:
-            return LV_DPI / 8;
-        case LV_STYLE_BG_GRAD_STOP:
-            return 255;
-        case LV_STYLE_TRANSFORM_ZOOM:
-            return LV_IMG_ZOOM_NONE;
-        case LV_STYLE_SCROLLBAR_TICKNESS:
-            return LV_DPX(10);
-    }
-
-    return 0;
-}
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_COLOR`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_color()`
- * @note for performance reasons it's not checked if the property really has color type
- */
-lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    lv_style_property_t prop_ori = prop;
-
-    lv_style_attr_t attr;
-    attr = prop_ori >> 8;
-
-    lv_color_t value_act;
-    lv_res_t res = LV_RES_INV;
-    const lv_obj_t * parent = obj;
-    while(parent) {
-        lv_style_list_t * list = lv_obj_get_style_list(parent, part);
-
-        lv_state_t state = lv_obj_get_state(parent, part);
-        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
-
-        res = _lv_style_list_get_color(list, prop, &value_act);
-        if(res == LV_RES_OK) return value_act;
-
-        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
-
-        /*If not found, check the `MAIN` style first*/
-        if(part != LV_OBJ_PART_MAIN) {
-            part = LV_OBJ_PART_MAIN;
-            continue;
-        }
-
-        /*Check the parent too.*/
-        parent = lv_obj_get_parent(parent);
-    }
-
-    /*Handle unset values*/
-    prop = prop & (~LV_STYLE_STATE_MASK);
-    switch(prop) {
-        case LV_STYLE_BG_COLOR:
-        case LV_STYLE_BG_GRAD_COLOR:
-            return LV_COLOR_WHITE;
-    }
-
-    return LV_COLOR_BLACK;
-}
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_OPA`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has opacity type
- */
-lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    lv_style_property_t prop_ori = prop;
-
-    lv_style_attr_t attr;
-    attr = prop_ori >> 8;
-
-    lv_opa_t value_act;
-    lv_res_t res = LV_RES_INV;
-    const lv_obj_t * parent = obj;
-    while(parent) {
-        lv_style_list_t * list = lv_obj_get_style_list(parent, part);
-
-        if(!list->ignore_cache && list->style_cnt > 0) {
-            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
-            bool def = false;
-            switch(prop & (~LV_STYLE_STATE_MASK)) {
-                case LV_STYLE_OPA_SCALE:
-                    if(list->opa_scale_cover) def = true;
-                    break;
-                case LV_STYLE_BG_OPA:
-                    if(list->bg_opa_cover) return LV_OPA_COVER;     /*Special case, not the default value is used*/
-                    if(list->bg_opa_transp) def = true;
-                    break;
-                case LV_STYLE_IMAGE_RECOLOR_OPA:
-                    if(list->img_recolor_opa_transp) def = true;
-                    break;
-            }
-
-            if(def) {
-                break;
-            }
-        }
-
-
-        lv_state_t state = lv_obj_get_state(parent, part);
-        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
-
-        res = _lv_style_list_get_opa(list, prop, &value_act);
-        if(res == LV_RES_OK) return value_act;
-
-        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
-
-        /*If not found, check the `MAIN` style first*/
-        if(part != LV_OBJ_PART_MAIN) {
-            part = LV_OBJ_PART_MAIN;
-            continue;
-        }
-
-        /*Check the parent too.*/
-        parent = lv_obj_get_parent(parent);
-    }
-
-    /*Handle unset values*/
-    prop = prop & (~LV_STYLE_STATE_MASK);
-    switch(prop) {
-        case LV_STYLE_BG_OPA:
-        case LV_STYLE_IMAGE_RECOLOR_OPA:
-        case LV_STYLE_PATTERN_RECOLOR_OPA:
-            return LV_OPA_TRANSP;
-    }
-
-    return LV_OPA_COVER;
-}
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_TEXT_FONT`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has pointer type
- */
-const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    lv_style_property_t prop_ori = prop;
-
-    lv_style_attr_t attr;
-    attr = prop_ori >> 8;
-
-    const void * value_act;
-    lv_res_t res = LV_RES_INV;
-    const lv_obj_t * parent = obj;
-    while(parent) {
-        lv_style_list_t * list = lv_obj_get_style_list(parent, part);
-
-        if(!list->ignore_cache && list->style_cnt > 0) {
-            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
-            bool def = false;
-            switch(prop  & (~LV_STYLE_STATE_MASK)) {
-                case LV_STYLE_VALUE_STR:
-                    if(list->value_txt_str) def = true;
-                    break;
-                case LV_STYLE_PATTERN_IMAGE:
-                    if(list->pattern_img_null) def = true;
-                    break;
-                case LV_STYLE_TEXT_FONT:
-                    if(list->text_font_normal) def = true;
-                    break;
-            }
-
-            if(def) {
-                break;
-            }
-        }
-
-        lv_state_t state = lv_obj_get_state(parent, part);
-        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
-
-        res = _lv_style_list_get_ptr(list, prop, &value_act);
-        if(res == LV_RES_OK)  return value_act;
-
-        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
-
-        /*If not found, check the `MAIN` style first*/
-        if(part != LV_OBJ_PART_MAIN) {
-            part = LV_OBJ_PART_MAIN;
-            continue;
-        }
-
-        /*Check the parent too.*/
-        parent = lv_obj_get_parent(parent);
-    }
-
-    /*Handle unset values*/
-    prop = prop & (~LV_STYLE_STATE_MASK);
-    switch(prop) {
-        case LV_STYLE_TEXT_FONT:
-        case LV_STYLE_VALUE_FONT:
-            return lv_theme_get_font_normal();
-#if LV_USE_ANIMATION
-        case LV_STYLE_TRANSITION_PATH:
-            return &lv_anim_path_def;
-#endif
-    }
-
-    return NULL;
-}
-
-/**
- * Get the local style of a part of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @return pointer to the local style if exists else `NULL`.
- */
-lv_style_t * lv_obj_get_local_style(lv_obj_t * obj, uint8_t part)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-    lv_style_list_t * style_list = lv_obj_get_style_list(obj, part);
-    return lv_style_list_get_local_style(style_list);
-}
 
 /*-----------------
  * Attribute get
  *----------------*/
 
-bool lv_obj_has_flag(lv_obj_t * obj, lv_obj_flag_t f)
+bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -3031,18 +1317,6 @@ bool lv_obj_get_adv_hittest(const lv_obj_t * obj)
 }
 
 
-/**
- * Get how the scrollbars should behave.
- * @param obj pointer to an object
- * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
-lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->scroll_mode;
-}
-
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@@ -3245,40 +1519,24 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
  * OTHER FUNCTIONS
  *------------------*/
 
+
 /**
- * Check if a given screen-space point is on an object's coordinates.
- *
- * This method is intended to be used mainly by advanced hit testing algorithms to check
- * whether the point is even within the object (as an optimization).
- * @param obj object to check
- * @param point screen-space point
+ * Get the really focused object by taking `focus_parent` into account.
+ * @param obj the start object
+ * @return the object to really focus
  */
-bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point)
+lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
 {
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad_hor;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad_hor;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad_ver;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad_ver;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
-#else
-    if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
-#endif
-        return false;
+    if(obj == NULL) return NULL;
+    const lv_obj_t * focus_obj = obj;
+    while(lv_obj_has_flag(focus_obj, LV_OBJ_FLAG_FOCUS_BUBBLE) != false && focus_obj != NULL) {
+        focus_obj = lv_obj_get_parent(focus_obj);
     }
-    return true;
+
+    return (lv_obj_t *)focus_obj;
 }
 
+
 /**
  * Hit-test an object given a particular point in screen space.
  * @param obj object to hit-test
@@ -3625,55 +1883,6 @@ lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part)
     return s;
 }
 
-/**
- * Fade in (from transparent to fully cover) an object and all its children using an `opa_scale` animation.
- * @param obj the object to fade in
- * @param time duration of the animation [ms]
- * @param delay wait before the animation starts [ms]
- */
-void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay)
-{
-#if LV_USE_ANIMATION
-    lv_anim_t a;
-    lv_anim_init(&a);
-    lv_anim_set_var(&a, obj);
-    lv_anim_set_values(&a, LV_OPA_TRANSP, LV_OPA_COVER);
-    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)opa_scale_anim);
-    lv_anim_set_ready_cb(&a, fade_in_anim_ready);
-    lv_anim_set_time(&a, time);
-    lv_anim_set_delay(&a, delay);
-    lv_anim_start(&a);
-#else
-    (void) obj;     /*Unused*/
-    (void) time;    /*Unused*/
-    (void) delay;   /*Unused*/
-#endif
-}
-
-/**
- * Fade out (from fully cover to transparent) an object and all its children using an `opa_scale` animation.
- * @param obj the object to fade in
- * @param time duration of the animation [ms]
- * @param delay wait before the animation starts [ms]
- */
-void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay)
-{
-#if LV_USE_ANIMATION
-    lv_anim_t a;
-    lv_anim_init(&a);
-    lv_anim_set_var(&a, obj);
-    lv_anim_set_values(&a, LV_OPA_COVER, LV_OPA_TRANSP);
-    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)opa_scale_anim);
-    lv_anim_set_time(&a, time);
-    lv_anim_set_delay(&a, delay);
-    lv_anim_start(&a);
-#else
-    (void) obj;     /*Unused*/
-    (void) time;    /*Unused*/
-    (void) delay;   /*Unused*/
-#endif
-}
-
 /**
  * Check if any object has a given type
  * @param obj pointer to an object
@@ -3745,7 +1954,7 @@ static void obj_del_core(lv_obj_t * obj)
     /*Remove the animations from this object*/
 #if LV_USE_ANIMATION
     lv_anim_del(obj, NULL);
-    trans_del(obj, 0xFF, 0xFF, NULL);
+    _lv_obj_remove_style_trans(obj);
 #endif
 
     /*Delete the user data*/
@@ -3950,21 +2159,19 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
     return LV_DESIGN_RES_OK;
 }
 
-
-/**
- * Get the really focused object by taking `focus_parent` into account.
- * @param obj the start object
- * @return the object to really focus
- */
-lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
+static void base_dir_refr_children(lv_obj_t * obj)
 {
-    if(obj == NULL) return NULL;
-    const lv_obj_t * focus_obj = obj;
-    while(lv_obj_has_flag(focus_obj, LV_OBJ_FLAG_FOCUS_BUBBLE) != false && focus_obj != NULL) {
-        focus_obj = lv_obj_get_parent(focus_obj);
-    }
+    lv_obj_t * child;
+    child = lv_obj_get_child(obj, NULL);
 
-    return (lv_obj_t *)focus_obj;
+    while(child) {
+        if(child->base_dir == LV_BIDI_DIR_INHERIT) {
+            lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
+            base_dir_refr_children(child);
+        }
+
+        child = lv_obj_get_child(obj, child);
+    }
 }
 
 /**
@@ -4001,7 +2208,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if(obj->grid) {
             lv_obj_t * child = param;
             if(child) {
-                if(lv_obj_is_grid_item(child)) lv_grid_full_refr(obj);
+                if(_lv_obj_is_grid_item(child)) lv_grid_full_refr(obj);
             } else {
                 lv_grid_full_refr(obj);
             }
@@ -4022,7 +2229,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
-        if(lv_obj_is_grid_item(obj)) lv_grid_full_refr(obj);
+        if(_lv_obj_is_grid_item(obj)) lv_grid_full_refr(obj);
 
         lv_obj_t * child = lv_obj_get_child(obj, NULL);
         while(child) {
@@ -4076,509 +2283,12 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+        _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
     }
 
     return res;
 }
 
-/**
- * Reposition the children of an object. (Called recursively)
- * @param obj pointer to an object which children will be repositioned
- * @param x_diff x coordinate shift
- * @param y_diff y coordinate shift
- */
-static void refresh_children_position(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff)
-{
-    lv_obj_t * i;
-    _LV_LL_READ(obj->child_ll, i) {
-        i->coords.x1 += x_diff;
-        i->coords.y1 += y_diff;
-        i->coords.x2 += x_diff;
-        i->coords.y2 += y_diff;
-
-        refresh_children_position(i, x_diff, y_diff);
-    }
-}
-
-/**
- * Refresh the style of all children of an object. (Called recursively)
- * @param style refresh objects only with this style_list.
- * @param obj pointer to an object
- */
-static void report_style_mod_core(void * style, lv_obj_t * obj)
-{
-    uint8_t part;
-    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
-        lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-        if(list == NULL) break;
-
-        uint8_t ci;
-        for(ci = 0; ci < list->style_cnt; ci++) {
-            lv_style_t * class = lv_style_list_get_style(list, ci);
-            if(class == style || style == NULL) {
-                lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
-                break;
-            }
-        }
-    }
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    while(child) {
-        report_style_mod_core(style, child);
-        child = lv_obj_get_child(obj, child);
-    }
-
-}
-
-
-/**
- * Recursively refresh the style of the children. Go deeper until a not NULL style is found
- * because the NULL styles are inherited from the parent
- * @param obj pointer to an object
- */
-static void refresh_children_style(lv_obj_t * obj)
-{
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    while(child != NULL) {
-        lv_obj_invalidate(child);
-        child->signal_cb(child, LV_SIGNAL_STYLE_CHG, NULL);
-        lv_obj_invalidate(child);
-
-        refresh_children_style(child); /*Check children too*/
-        child = lv_obj_get_child(obj, child);
-    }
-}
-
-static void base_dir_refr_children(lv_obj_t * obj)
-{
-    lv_obj_t * child;
-    child = lv_obj_get_child(obj, NULL);
-
-    while(child) {
-        if(child->base_dir == LV_BIDI_DIR_INHERIT) {
-            lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
-            base_dir_refr_children(child);
-        }
-
-        child = lv_obj_get_child(obj, child);
-    }
-}
-
-static void obj_align_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, bool x_set, bool y_set,
-                           lv_coord_t x_ofs, lv_coord_t y_ofs)
-{
-    lv_point_t new_pos;
-    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
-
-    /*Bring together the coordination system of base and obj*/
-    lv_obj_t * par        = lv_obj_get_parent(obj);
-    lv_coord_t par_abs_x  = par->coords.x1;
-    lv_coord_t par_abs_y  = par->coords.y1;
-    new_pos.x += x_ofs;
-    new_pos.y += y_ofs;
-    new_pos.x -= par_abs_x;
-    new_pos.y -= par_abs_y;
-
-    if(x_set && y_set) lv_obj_set_pos(obj, new_pos.x, new_pos.y);
-    else if(x_set) lv_obj_set_x(obj, new_pos.x);
-    else if(y_set) lv_obj_set_y(obj, new_pos.y);
-}
-
-static void obj_align_mid_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,  bool x_set, bool y_set,
-                               lv_coord_t x_ofs, lv_coord_t y_ofs)
-{
-    lv_coord_t new_x = lv_obj_get_x(obj);
-    lv_coord_t new_y = lv_obj_get_y(obj);
-
-    lv_coord_t obj_w_half = lv_obj_get_width(obj) / 2;
-    lv_coord_t obj_h_half = lv_obj_get_height(obj) / 2;
-
-
-    switch(align) {
-        case LV_ALIGN_CENTER:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_TOP_LEFT:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-        case LV_ALIGN_IN_TOP_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_TOP_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_BOTTOM_LEFT:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-        case LV_ALIGN_IN_BOTTOM_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_BOTTOM_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_LEFT_MID:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_RIGHT_MID:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_LEFT:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_LEFT:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_TOP:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_MID:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_BOTTOM:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_TOP:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_MID:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_BOTTOM:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-    }
-
-    /*Bring together the coordination system of base and obj*/
-    lv_obj_t * par        = lv_obj_get_parent(obj);
-    lv_coord_t base_abs_x = base->coords.x1;
-    lv_coord_t base_abs_y = base->coords.y1;
-    lv_coord_t par_abs_x  = par->coords.x1;
-    lv_coord_t par_abs_y  = par->coords.y1;
-    new_x += x_ofs + base_abs_x;
-    new_y += y_ofs + base_abs_y;
-    new_x -= par_abs_x;
-    new_y -= par_abs_y;
-    if(x_set && y_set) lv_obj_set_pos(obj, new_x, new_y);
-    else if(x_set) lv_obj_set_x(obj, new_x);
-    else if(y_set) lv_obj_set_y(obj, new_y);
-
-}
-
-
-
-#if LV_USE_ANIMATION
-
-/**
- * Allocate and initialize a transition for a property of an object if the properties value is different in the new state.
- * It allocates `lv_style_trans_t` in `_lv_obj_style_trans_ll` and set only `start/end_values`. No animation will be created here.
- * @param obj and object to add the transition
- * @param prop the property to apply the transaction
- * @param part the part of the object to apply the transaction
- * @param prev_state the previous state of the objects
- * @param new_state the new state of the object
- * @return pointer to the allocated `the transaction` variable or `NULL` if no transition created
- */
-static lv_style_trans_t * trans_create(lv_obj_t * obj, lv_style_property_t prop, uint8_t part, lv_state_t prev_state,
-                                       lv_state_t new_state)
-{
-    lv_style_trans_t * tr;
-    lv_style_list_t * style_list = lv_obj_get_style_list(obj, part);
-    lv_style_t * style_trans = _lv_style_list_get_transition_style(style_list);
-
-    /*Get the previous and current values*/
-    if((prop & 0xF) < LV_STYLE_ID_COLOR) { /*Int*/
-        style_list->skip_trans = 1;
-        obj->state = prev_state;
-        lv_style_int_t int1 = _lv_obj_get_style_int(obj, part, prop);
-        obj->state = new_state;
-        lv_style_int_t int2 =  _lv_obj_get_style_int(obj, part, prop);
-        style_list->skip_trans = 0;
-
-        if(int1 == int2)  return NULL;
-        obj->state = prev_state;
-        int1 = _lv_obj_get_style_int(obj, part, prop);
-        obj->state = new_state;
-        _lv_style_set_int(style_trans, prop, int1);   /*Be sure `trans_style` has a valid value */
-
-        if(prop == LV_STYLE_RADIUS) {
-            if(int1 == LV_RADIUS_CIRCLE || int2 == LV_RADIUS_CIRCLE) {
-                lv_coord_t whalf = lv_obj_get_width(obj) / 2;
-                lv_coord_t hhalf = lv_obj_get_width(obj) / 2;
-                if(int1 == LV_RADIUS_CIRCLE) int1 = LV_MATH_MIN(whalf + 1, hhalf + 1);
-                if(int2 == LV_RADIUS_CIRCLE) int2 = LV_MATH_MIN(whalf + 1, hhalf + 1);
-            }
-        }
-
-        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
-        LV_ASSERT_MEM(tr);
-        if(tr == NULL) return NULL;
-        tr->start_value._int = int1;
-        tr->end_value._int = int2;
-    }
-    else if((prop & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
-        style_list->skip_trans = 1;
-        obj->state = prev_state;
-        lv_color_t c1 = _lv_obj_get_style_color(obj, part, prop);
-        obj->state = new_state;
-        lv_color_t c2 =  _lv_obj_get_style_color(obj, part, prop);
-        style_list->skip_trans = 0;
-
-        if(c1.full == c2.full) return NULL;
-        obj->state = prev_state;
-        c1 = _lv_obj_get_style_color(obj, part, prop);
-        obj->state = new_state;
-        _lv_style_set_color(style_trans, prop, c1);    /*Be sure `trans_style` has a valid value */
-
-        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
-        LV_ASSERT_MEM(tr);
-        if(tr == NULL) return NULL;
-        tr->start_value._color = c1;
-        tr->end_value._color = c2;
-    }
-    else if((prop & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
-        style_list->skip_trans = 1;
-        obj->state = prev_state;
-        lv_opa_t o1 = _lv_obj_get_style_opa(obj, part, prop);
-        obj->state = new_state;
-        lv_opa_t o2 =  _lv_obj_get_style_opa(obj, part, prop);
-        style_list->skip_trans = 0;
-
-        if(o1 == o2) return NULL;
-
-        obj->state = prev_state;
-        o1 = _lv_obj_get_style_opa(obj, part, prop);
-        obj->state = new_state;
-        _lv_style_set_opa(style_trans, prop, o1);   /*Be sure `trans_style` has a valid value */
-
-        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
-        LV_ASSERT_MEM(tr);
-        if(tr == NULL) return NULL;
-        tr->start_value._opa = o1;
-        tr->end_value._opa = o2;
-    }
-    else {      /*Ptr*/
-        obj->state = prev_state;
-        style_list->skip_trans = 1;
-        const void * p1 = _lv_obj_get_style_ptr(obj, part, prop);
-        obj->state = new_state;
-        const void * p2 = _lv_obj_get_style_ptr(obj, part, prop);
-        style_list->skip_trans = 0;
-
-        if(memcmp(&p1, &p2, sizeof(const void *)) == 0)  return NULL;
-        obj->state = prev_state;
-        p1 = _lv_obj_get_style_ptr(obj, part, prop);
-        obj->state = new_state;
-        _lv_style_set_ptr(style_trans, prop, p1);   /*Be sure `trans_style` has a valid value */
-
-        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
-        LV_ASSERT_MEM(tr);
-        if(tr == NULL) return NULL;
-        tr->start_value._ptr = p1;
-        tr->end_value._ptr = p2;
-    }
-
-    return tr;
-}
-
-/**
- * Remove the transition from object's part's property.
- * - Remove the transition from `_lv_obj_style_trans_ll` and free it
- * - Delete pending transitions
- * @param obj pointer to an object which transition(s) should be removed
- * @param part a part of object or 0xFF to remove from all parts
- * @param prop a property or 0xFF to remove all properties
- * @param tr_limit delete transitions only "older" then this. `NULL` is not used
- */
-static void trans_del(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_trans_t * tr_limit)
-{
-    lv_style_trans_t * tr;
-    lv_style_trans_t * tr_prev;
-    tr = _lv_ll_get_tail(&LV_GC_ROOT(_lv_obj_style_trans_ll));
-    while(tr != NULL) {
-        if(tr == tr_limit) break;
-
-        /*'tr' might be deleted, so get the next object while 'tr' is valid*/
-        tr_prev = _lv_ll_get_prev(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
-
-        if(tr->obj == obj && (part == tr->part || part == 0xFF) && (prop == tr->prop || prop == 0xFF)) {
-            /* Remove the transitioned property from trans. style
-             * to allow changing it by normal styles*/
-            lv_style_list_t * list = lv_obj_get_style_list(tr->obj, tr->part);
-            lv_style_t * style_trans = _lv_style_list_get_transition_style(list);
-            lv_style_remove_prop(style_trans, tr->prop);
-
-            lv_anim_del(tr, NULL);
-            _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
-            lv_mem_free(tr);
-        }
-        tr = tr_prev;
-    }
-}
-
-static void trans_anim_cb(lv_style_trans_t * tr, lv_anim_value_t v)
-{
-    lv_style_list_t * list = lv_obj_get_style_list(tr->obj, tr->part);
-    lv_style_t * style = _lv_style_list_get_transition_style(list);
-
-    if((tr->prop & 0xF) < LV_STYLE_ID_COLOR) { /*Value*/
-        lv_style_int_t x;
-        if(v == 0) x = tr->start_value._int;
-        else if(v == 255) x = tr->end_value._int;
-        else x = tr->start_value._int + ((int32_t)((int32_t)(tr->end_value._int - tr->start_value._int) * v) >> 8);
-        _lv_style_set_int(style, tr->prop, x);
-    }
-    else if((tr->prop & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
-        lv_color_t x;
-        if(v <= 0) x = tr->start_value._color;
-        else if(v >= 255) x = tr->end_value._color;
-        else x = lv_color_mix(tr->end_value._color, tr->start_value._color, v);
-        _lv_style_set_color(style, tr->prop, x);
-    }
-    else if((tr->prop & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
-        lv_opa_t x;
-        if(v <= 0) x = tr->start_value._opa;
-        else if(v >= 255) x = tr->end_value._opa;
-        else x = tr->start_value._opa + (((tr->end_value._opa - tr->start_value._opa) * v) >> 8);
-        _lv_style_set_opa(style, tr->prop, x);
-    }
-    else {
-        const void * x;
-        if(v < 128) x = tr->start_value._ptr;
-        else x = tr->end_value._ptr;
-        _lv_style_set_ptr(style, tr->prop, x);
-    }
-    lv_obj_refresh_style(tr->obj, tr->part, tr->prop);
-
-}
-
-static void trans_anim_start_cb(lv_anim_t * a)
-{
-    lv_style_trans_t * tr = a->var;
-
-    lv_style_property_t prop_tmp = tr->prop;
-
-    /*Start the animation from the current value*/
-    if((prop_tmp & 0xF) < LV_STYLE_ID_COLOR) { /*Int*/
-        tr->start_value._int = _lv_obj_get_style_int(tr->obj, tr->part, prop_tmp);
-    }
-    else if((prop_tmp & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
-        tr->start_value._color = _lv_obj_get_style_color(tr->obj, tr->part, prop_tmp);
-    }
-    else if((prop_tmp & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
-        tr->start_value._opa = _lv_obj_get_style_opa(tr->obj, tr->part, prop_tmp);
-    }
-    else {      /*Ptr*/
-        tr->start_value._ptr = _lv_obj_get_style_ptr(tr->obj, tr->part, prop_tmp);
-    }
-
-    /*Init prop to an invalid values to be sure `trans_del` won't delete this added `tr`*/
-    tr->prop = 0;
-    /*Delete the relate transition if any*/
-    trans_del(tr->obj, tr->part, prop_tmp, tr);
-
-    tr->prop = prop_tmp;
-
-}
-
-static void trans_anim_ready_cb(lv_anim_t * a)
-{
-    lv_style_trans_t * tr = a->var;
-
-    /* Remove the transitioned property from trans. style
-     * if there no more transitions for this property
-     * It allows changing it by normal styles*/
-
-    bool running = false;
-    lv_style_trans_t * tr_i;
-    _LV_LL_READ(LV_GC_ROOT(_lv_obj_style_trans_ll), tr_i) {
-        if(tr_i != tr && tr_i->obj == tr->obj && tr_i->part == tr->part && tr_i->prop == tr->prop) {
-            running = true;
-        }
-    }
-
-    if(!running) {
-        lv_style_list_t * list = lv_obj_get_style_list(tr->obj, tr->part);
-        lv_style_t * style_trans = _lv_style_list_get_transition_style(list);
-        lv_style_remove_prop(style_trans, tr->prop);
-    }
-
-    _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
-    lv_mem_free(tr);
-}
-
-static void opa_scale_anim(lv_obj_t * obj, lv_anim_value_t v)
-{
-    lv_obj_set_style_local_opa_scale(obj, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, v);
-}
-
-static void fade_in_anim_ready(lv_anim_t * a)
-{
-    lv_style_remove_prop(lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
-}
-
-
-static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
-{
-    lv_obj_scroll_by_raw(obj, v - obj->scroll.x, 0);
-}
-
-static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
-{
-    lv_obj_scroll_by_raw(obj, 0, v - obj->scroll.y);
-}
-#endif
 
 static void lv_event_mark_deleted(lv_obj_t * obj)
 {
@@ -4769,213 +2479,3 @@ static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
     }
 }
 
-
-static bool style_prop_is_cacheble(lv_style_property_t prop)
-{
-
-    switch(prop) {
-        case LV_STYLE_PROP_ALL:
-        case LV_STYLE_BG_GRAD_DIR:
-        case LV_STYLE_CLIP_CORNER:
-        case LV_STYLE_TEXT_LETTER_SPACE:
-        case LV_STYLE_TEXT_LINE_SPACE:
-        case LV_STYLE_TEXT_FONT:
-        case LV_STYLE_TRANSFORM_ANGLE:
-        case LV_STYLE_TRANSFORM_WIDTH:
-        case LV_STYLE_TRANSFORM_HEIGHT:
-        case LV_STYLE_TRANSFORM_ZOOM:
-        case LV_STYLE_BORDER_WIDTH:
-        case LV_STYLE_OUTLINE_WIDTH:
-        case LV_STYLE_RADIUS:
-        case LV_STYLE_SHADOW_WIDTH:
-        case LV_STYLE_OPA_SCALE:
-        case LV_STYLE_BG_OPA:
-        case LV_STYLE_BORDER_SIDE:
-        case LV_STYLE_BORDER_POST:
-        case LV_STYLE_IMAGE_RECOLOR_OPA:
-        case LV_STYLE_VALUE_STR:
-        case LV_STYLE_PATTERN_IMAGE:
-        case LV_STYLE_PAD_TOP:
-        case LV_STYLE_PAD_BOTTOM:
-        case LV_STYLE_PAD_LEFT:
-        case LV_STYLE_PAD_RIGHT:
-        case LV_STYLE_MARGIN_TOP:
-        case LV_STYLE_MARGIN_BOTTOM:
-        case LV_STYLE_MARGIN_LEFT:
-        case LV_STYLE_MARGIN_RIGHT:
-        case LV_STYLE_BG_BLEND_MODE:
-        case LV_STYLE_BORDER_BLEND_MODE:
-        case LV_STYLE_IMAGE_BLEND_MODE:
-        case LV_STYLE_LINE_BLEND_MODE:
-        case LV_STYLE_OUTLINE_BLEND_MODE:
-        case LV_STYLE_PATTERN_BLEND_MODE:
-        case LV_STYLE_SHADOW_BLEND_MODE:
-        case LV_STYLE_TEXT_BLEND_MODE:
-        case LV_STYLE_VALUE_BLEND_MODE:
-            return true;
-            break;
-        default:
-            return false;
-    }
-}
-
-/**
- * Update the cache of style list
- * @param obj pointer to an obejct
- * @param part the part of the object
- * @param prop the property which triggered the update
- */
-static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
-{
-    if(style_prop_is_cacheble(prop) == false) return;
-
-    lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-
-    bool ignore_cache_ori = list->ignore_cache;
-    list->ignore_cache = 1;
-
-#if LV_USE_OPA_SCALE
-    list->opa_scale_cover    = lv_obj_get_style_opa_scale(obj, part) == LV_OPA_COVER ? 1 : 0;
-#else
-    list->opa_scale_cover    = 1;
-#endif
-    list->text_decor_none    = lv_obj_get_style_text_decor(obj, part) == LV_TEXT_DECOR_NONE ? 1 : 0;
-    list->text_font_normal    = lv_obj_get_style_text_font(obj, part) == LV_THEME_DEFAULT_FONT_NORMAL ? 1 : 0;
-
-    list->text_space_zero = 1;
-    if(lv_obj_get_style_text_letter_space(obj, part) != 0 ||
-       lv_obj_get_style_text_line_space(obj, part) != 0) {
-        list->text_space_zero = 0;
-    }
-
-
-    lv_opa_t bg_opa = lv_obj_get_style_bg_opa(obj, part);
-    list->bg_opa_transp    = bg_opa == LV_OPA_TRANSP ? 1 : 0;
-    list->bg_opa_cover     = bg_opa == LV_OPA_COVER ? 1 : 0;
-
-    list->bg_grad_dir_none  = lv_obj_get_style_bg_grad_dir(obj, part) == LV_GRAD_DIR_NONE ? 1 : 0;
-    list->border_width_zero = lv_obj_get_style_border_width(obj, part) == 0 ? 1 : 0;
-    list->border_side_full = lv_obj_get_style_border_side(obj, part) == LV_BORDER_SIDE_FULL ? 1 : 0;
-    list->border_post_off = lv_obj_get_style_border_post(obj, part) == 0 ? 1 : 0;
-    list->clip_corner_off   = lv_obj_get_style_clip_corner(obj, part) == false ? 1 : 0;
-    list->img_recolor_opa_transp    = lv_obj_get_style_image_recolor_opa(obj, part) == LV_OPA_TRANSP ? 1 : 0;
-    list->outline_width_zero    = lv_obj_get_style_outline_width(obj, part) == 0 ? 1 : 0;
-    list->pattern_img_null    = lv_obj_get_style_pattern_image(obj, part) == NULL ? 1 : 0;
-    list->radius_zero    = lv_obj_get_style_radius(obj, part) == 0 ? 1 : 0;
-    list->shadow_width_zero    = lv_obj_get_style_shadow_width(obj, part) == 0 ? 1 : 0;
-    list->value_txt_str    = lv_obj_get_style_value_str(obj, part) == NULL ? 1 : 0;
-
-
-    list->transform_all_zero  = 1;
-    if(lv_obj_get_style_transform_angle(obj, part) != 0 ||
-       lv_obj_get_style_transform_width(obj, part) != 0 ||
-       lv_obj_get_style_transform_height(obj, part) != 0 ||
-       lv_obj_get_style_transform_zoom(obj, part) != LV_IMG_ZOOM_NONE) {
-        list->transform_all_zero  = 0;
-    }
-
-    list->pad_all_zero  = 1;
-    if(lv_obj_get_style_pad_top(obj, part) != 0 ||
-       lv_obj_get_style_pad_bottom(obj, part) != 0 ||
-       lv_obj_get_style_pad_left(obj, part) != 0 ||
-       lv_obj_get_style_pad_right(obj, part) != 0) {
-        list->pad_all_zero  = 0;
-    }
-
-    list->margin_all_zero  = 1;
-    if(lv_obj_get_style_margin_top(obj, part) != 0 ||
-       lv_obj_get_style_margin_bottom(obj, part) != 0 ||
-       lv_obj_get_style_margin_left(obj, part) != 0 ||
-       lv_obj_get_style_margin_right(obj, part) != 0) {
-        list->margin_all_zero  = 0;
-    }
-
-    list->blend_mode_all_normal = 1;
-#if LV_USE_BLEND_MODES
-    if(lv_obj_get_style_bg_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_border_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_pattern_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_outline_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_value_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_text_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_line_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_image_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
-       lv_obj_get_style_shadow_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL) {
-        list->blend_mode_all_normal = 0;
-    }
-#endif
-    list->ignore_cache = ignore_cache_ori;
-    list->valid_cache = 1;
-}
-
-/**
- * Update the cache of style list
- * @param obj pointer to an object
- * @param part the part of the object
- */
-static void update_style_cache_children(lv_obj_t * obj)
-{
-    uint8_t part;
-    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
-        lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-        if(list == NULL) break;
-
-        bool ignore_cache_ori = list->ignore_cache;
-        list->ignore_cache = 1;
-
-        list->opa_scale_cover    = lv_obj_get_style_opa_scale(obj, part) == LV_OPA_COVER ? 1 : 0;
-        list->text_decor_none    = lv_obj_get_style_text_decor(obj, part) == LV_TEXT_DECOR_NONE ? 1 : 0;
-        list->text_font_normal    = lv_obj_get_style_text_font(obj, part) == lv_theme_get_font_normal() ? 1 : 0;
-        list->img_recolor_opa_transp    = lv_obj_get_style_image_recolor_opa(obj, part) == LV_OPA_TRANSP ? 1 : 0;
-
-        list->text_space_zero = 1;
-        if(lv_obj_get_style_text_letter_space(obj, part) != 0 ||
-           lv_obj_get_style_text_line_space(obj, part) != 0) {
-            list->text_space_zero = 0;
-        }
-
-        list->ignore_cache = ignore_cache_ori;
-    }
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    while(child) {
-        update_style_cache_children(child);
-        child = lv_obj_get_child(obj, child);
-    }
-
-}
-
-/**
- * Mark the object and all of it's children's style lists as invalid.
- * The cache will be updated when a cached property asked nest time
- * @param obj pointer to an object
- */
-static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    if(style_prop_is_cacheble(prop) == false) return;
-
-    if(part != LV_OBJ_PART_ALL) {
-        lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-        if(list == NULL) return;
-        list->valid_cache = 0;
-    }
-    else {
-
-        for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
-            lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-            if(list == NULL) break;
-            list->valid_cache = 0;
-        }
-        for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
-            lv_style_list_t * list = lv_obj_get_style_list(obj, part);
-            if(list == NULL) break;
-            list->valid_cache = 0;
-        }
-    }
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    while(child) {
-        update_style_cache_children(child);
-        child = lv_obj_get_child(obj, child);
-    }
-}
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index a3830df74..7e99a647e 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -184,14 +184,6 @@ enum {
 
 typedef uint8_t lv_dir_t;
 
-enum {
-    LV_SCROLL_SNAP_ALIGN_NONE,
-    LV_SCROLL_SNAP_ALIGN_START,
-    LV_SCROLL_SNAP_ALIGN_END,
-    LV_SCROLL_SNAP_ALIGN_CENTER
-};
-typedef uint8_t lv_scroll_snap_align_t;
-
 
 enum {
     LV_OBJ_FLAG_HIDDEN          = (1 << 0),
@@ -207,14 +199,10 @@ enum {
 };
 typedef uint16_t lv_obj_flag_t;
 
-/** Scrollbar modes: shows when should the scrollbars be visible*/
-enum {
-    LV_SCROLL_MODE_OFF    = 0x0, /**< Never show scroll bars*/
-    LV_SCROLL_MODE_ON     = 0x1, /**< Always show scroll bars*/
-    LV_SCROLL_MODE_ACTIVE = 0x2, /**< Show scroll bars when object is being scrolled*/
-    LV_SCROLL_MODE_AUTO   = 0x3, /**< Show scroll bars when the content is large enough to be scrolled*/
-};
-typedef uint8_t lv_scroll_mode_t;
+
+#include "lv_obj_pos.h"
+#include "lv_obj_scroll.h"
+
 
 typedef struct _lv_obj_t {
     struct _lv_obj_t * parent; /**< Pointer to the parent object*/
@@ -420,171 +408,6 @@ void lv_obj_move_background(lv_obj_t * obj);
  * Coordinate set
  * ------------------*/
 
-/**
- * Set relative the position of an object (relative to the parent)
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
-
-/**
- * Set the x coordinate of a object
- * @param obj pointer to an object
- * @param x new distance from the left side from the parent
- */
-void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x);
-
-/**
- * Set the y coordinate of a object
- * @param obj pointer to an object
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y);
-
-
-void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h);
-
-/**
- * Set the size of an object
- * @param obj pointer to an object
- * @param w new width
- * @param h new height
- */
-void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h);
-
-/**
- * Set the width of an object
- * @param obj pointer to an object
- * @param w new width
- */
-void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w);
-
-/**
- * Set the height of an object
- * @param obj pointer to an object
- * @param h new height
- */
-void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h);
-
-/**
- * Set the width reduced by the left and right padding.
- * @param obj pointer to an object
- * @param w the width without paddings
- */
-void lv_obj_set_width_fit(lv_obj_t * obj, lv_coord_t w);
-
-/**
- * Set the height reduced by the top and bottom padding.
- * @param obj pointer to an object
- * @param h the height without paddings
- */
-void lv_obj_set_height_fit(lv_obj_t * obj, lv_coord_t h);
-
-/**
- * Set the width of an object by taking the left and right margin into account.
- * The object width will be `obj_w = w - margin_left - margin_right`
- * @param obj pointer to an object
- * @param w new height including margins
- */
-void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w);
-
-/**
- * Set the height of an object by taking the top and bottom margin into account.
- * The object height will be `obj_h = h - margin_top - margin_bottom`
- * @param obj pointer to an object
- * @param h new height including margins
- */
-void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
-
-/**
- * Align an object to an other object.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_ofs x coordinate offset after alignment
- * @param y_ofs y coordinate offset after alignment
- */
-void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
-
-/**
- * Moves all children with horizontally or vertically.
- * It doesn't take into account any limits so any values are possible
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
-void lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
-
-/**
- * Moves all children with horizontally or vertically.
- * Limits the scroll to the bounding box of the children.
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
-void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
-
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- * @param y the y coordinate to scroll to
- */
-void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
-
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- */
-void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
-
-/**
- * Scroll the a given y coordinate to the top side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param y the y coordinate to scroll to
- */
-void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
-
-
-/**
- * Return the height of the area above the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj);
-
-/**
- * Return the height of the area below the parent.
- * That is the number of pixels the object can be scrolled up.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
-
-
-/**
- * Return the weight of the area on the left the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj);
-
-/**
- * Return the width of the area below the object.
- * That is the number of pixels the object can be scrolled left.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj);
-
 /**
  * Set the size of an extended clickable area
  * @param obj pointer to an object
@@ -599,134 +422,6 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
  * Appearance set
  *--------------------*/
 
-/**
- * Add a new style to the style list of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param style pointer to a style to add (Only its pointer will be saved)
- */
-void lv_obj_add_style(lv_obj_t * obj, uint8_t part, lv_style_t * style);
-
-/**
- * Remove a style from the style list of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param style pointer to a style to remove
- */
-void lv_obj_remove_style(lv_obj_t * obj, uint8_t part, lv_style_t * style);
-
-/**
- * Reset a style to the default (empty) state.
- * Release all used memories and cancel pending related transitions.
- * Typically used in `LV_SIGN_CLEAN_UP.
- * @param obj pointer to an object
- * @param part the part of the object which style list should be reseted.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- */
-void lv_obj_clean_style_list(lv_obj_t * obj, uint8_t part);
-
-/**
- * Reset a style to the default (empty) state.
- * Release all used memories and cancel pending related transitions.
- * Also notifies the object about the style change.
- * @param obj pointer to an object
- * @param part the part of the object which style list should be reseted.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- */
-void lv_obj_reset_style_list(lv_obj_t * obj, uint8_t part);
-
-/**
- * Notify an object (and its children) about its style is modified
- * @param obj pointer to an object
- * @param prop `LV_STYLE_PROP_ALL` or an `LV_STYLE_...` property. It is used to optimize what needs to be refreshed.
- */
-void lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Notify all object if a style is modified
- * @param style pointer to a style. Only the objects with this style will be notified
- *               (NULL to notify all objects)
- */
-void lv_obj_report_style_mod(lv_style_t * style);
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has color type
- */
-void _lv_obj_set_style_local_color(lv_obj_t * obj, uint8_t type, lv_style_property_t prop, lv_color_t color);
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has integer type
- */
-void _lv_obj_set_style_local_int(lv_obj_t * obj, uint8_t type, lv_style_property_t prop, lv_style_int_t value);
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has opacity type
- */
-void _lv_obj_set_style_local_opa(lv_obj_t * obj, uint8_t type, lv_style_property_t prop, lv_opa_t opa);
-
-/**
- * Set a local style property of a part of an object in a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @param the value to set
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has pointer type
- */
-void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t type, lv_style_property_t prop, const void * value);
-
-/**
- * Remove a local style property from a part of an object with a given state.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be removed.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop a style property ORed with a state.
- * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
- * @note shouldn't be used directly. Use the specific property remove functions instead.
- *       For example: `lv_obj_style_remove_border_opa()`
- * @return true: the property was found and removed; false: the property was not found
- */
-bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Enable/disable the use of style cahche for an object
- * @param obj pointer to an object
- * @param dis true: disable; false: enable (re-enable)
- */
-void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
-
 /*-----------------
  * Attribute set
  *----------------*/
@@ -738,14 +433,6 @@ void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
  */
 void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en);
 
-
-/**
- * Set how the scrollbars should behave.
- * @param obj pointer to an object
- * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
-void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode);
-
 /**
  * Set the base direction of the object
  * @param obj pointer to an object
@@ -783,14 +470,6 @@ void lv_obj_add_state(lv_obj_t * obj, lv_state_t state);
  */
 void lv_obj_clear_state(lv_obj_t * obj, lv_state_t state);
 
-#if LV_USE_ANIMATION
-/**
- * Finish all pending transitions on a part of an object
- * @param obj pointer to an object
- * @param part part of the object, e.g `LV_BRN_PART_MAIN` or `LV_OBJ_PART_ALL` for all parts
- */
-void lv_obj_finish_transitions(lv_obj_t * obj, uint8_t part);
-#endif
 
 /**
  * Set a an event handler function for an object.
@@ -947,104 +626,6 @@ uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj);
  * Coordinate get
  *--------------------*/
 
-/**
- * Copy the coordinates of an object to an area
- * @param obj pointer to an object
- * @param cords_p pointer to an area to store the coordinates
- */
-void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * cords_p);
-
-/**
- * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
- * (Without the size of the border or other extra graphical elements)
- * @param coords_p store the result area here
- */
-void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p);
-
-/**
- * Get the x coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the left side of its parent
- */
-lv_coord_t lv_obj_get_x(const lv_obj_t * obj);
-
-/**
- * Get the y coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the top of its parent
- */
-lv_coord_t lv_obj_get_y(const lv_obj_t * obj);
-
-/**
- * Get the width of an object
- * @param obj pointer to an object
- * @return the width
- */
-lv_coord_t lv_obj_get_width(const lv_obj_t * obj);
-
-/**
- * Get the height of an object
- * @param obj pointer to an object
- * @return the height
- */
-lv_coord_t lv_obj_get_height(const lv_obj_t * obj);
-
-/**
- * Get that width reduced by the left and right padding.
- * @param obj pointer to an object
- * @return the width which still fits into the container
- */
-lv_coord_t lv_obj_get_width_fit(const lv_obj_t * obj);
-
-/**
- * Get that height reduced by the top an bottom padding.
- * @param obj pointer to an object
- * @return the height which still fits into the container
- */
-lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj);
-
-/**
- * Get the height of an object by taking the top and bottom margin into account.
- * The returned height will be `obj_h + margin_top + margin_bottom`
- * @param obj pointer to an object
- * @return the height including thee margins
- */
-lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj);
-
-/**
- * Get the width of an object by taking the left and right margin into account.
- * The returned width will be `obj_w + margin_left + margin_right`
- * @param obj pointer to an object
- * @return the height including thee margins
- */
-lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj);
-
-/**
- * Divide the width of the object and get the width of a given number of columns.
- * Take paddings into account.
- * @param obj pointer to an object
- * @param div indicates how many columns are assumed.
- * If 1 the width will be set the the parent's width
- * If 2 only half parent width - inner padding of the parent
- * If 3 only third parent width - 2 * inner padding of the parent
- * @param span how many columns are combined
- * @return the width according to the given parameters
- */
-lv_coord_t lv_obj_get_width_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
-
-/**
- * Divide the height of the object and get the width of a given number of columns.
- * Take paddings into account.
- * @param obj pointer to an object
- * @param div indicates how many rows are assumed.
- * If 1 the height will be set the the parent's height
- * If 2 only half parent height - inner padding of the parent
- * If 3 only third parent height - 2 * inner padding of the parent
- * @param span how many rows are combined
- * @return the height according to the given parameters
- */
-lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
-
 /**
  * Get the left padding of extended clickable area
  * @param obj pointer to an object
@@ -1084,97 +665,13 @@ lv_coord_t lv_obj_get_ext_draw_pad(const lv_obj_t * obj);
  * Appearance get
  *---------------*/
 
-/**
- * Get the style list of an object's part.
- * @param obj pointer to an object.
- * @param part part the part of the object which style list should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @return pointer to the style list. (Can be `NULL`)
- */
-lv_style_list_t * lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part);
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_WIDTH`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_width()`
- * @note for performance reasons it's not checked if the property really has integer type
- */
-lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_COLOR`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_color()`
- * @note for performance reasons it's not checked if the property really has color type
- */
-lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_BORDER_OPA`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has opacity type
- */
-lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Get a style property of a part of an object in the object's current state.
- * If there is a running transitions it is taken into account
- * @param obj pointer to an object
- * @param part the part of the object which style property should be get.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @param prop the property to get. E.g. `LV_STYLE_TEXT_FONT`.
- *  The state of the object will be added internally
- * @return the value of the property of the given part in the current state.
- * If the property is not found a default value will be returned.
- * @note shouldn't be used directly. Use the specific property get functions instead.
- *       For example: `lv_obj_style_get_border_opa()`
- * @note for performance reasons it's not checked if the property really has pointer type
- */
-const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
-
-/**
- * Get the local style of a part of an object.
- * @param obj pointer to an object
- * @param part the part of the object which style property should be set.
- * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
- * @return pointer to the local style if exists else `NULL`.
- */
-lv_style_t * lv_obj_get_local_style(lv_obj_t * obj, uint8_t part);
-
-
-#include "lv_obj_style_dec.h"
 
 /*-----------------
  * Attribute get
  *----------------*/
 
 
-bool lv_obj_has_flag(lv_obj_t * obj, lv_obj_flag_t f);
+bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f);
 
 /**
  * Get whether advanced hit-testing is enabled on an object
@@ -1326,21 +823,6 @@ void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t
  */
 lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part);
 
-/**
- * Fade in (from transparent to fully cover) an object and all its children using an `opa_scale` animation.
- * @param obj the object to fade in
- * @param time duration of the animation [ms]
- * @param delay wait before the animation starts [ms]
- */
-void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay);
-
-/**
- * Fade out (from fully cover to transparent) an object and all its children using an `opa_scale` animation.
- * @param obj the object to fade in
- * @param time duration of the animation [ms]
- * @param delay wait before the animation starts [ms]
- */
-void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
 
 /**
  * Check if any object has a given type
@@ -1358,6 +840,9 @@ bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
  */
 bool lv_debug_check_obj_valid(const lv_obj_t * obj);
 
+void _lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff);
+
+#include "lv_obj_style.h"
 
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
new file mode 100644
index 000000000..ec9c17dfe
--- /dev/null
+++ b/src/lv_core/lv_obj_pos.c
@@ -0,0 +1,670 @@
+/**
+ * @file lv_obj_pos.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Set relative the position of an object (relative to the parent)
+ * @param obj pointer to an object
+ * @param x new distance from the left side of the parent plus the parent's left padding or a grid cell
+ * @param y new distance from the top side of the parent  plus the parent's right padding or a grid cell
+ * @note Zero value value means place the object is on the left padding of the parent, and not on the left edge.
+ * @note A grid cell can be and explicit placement with cell position and span:
+ *         `LV_GRID_CELL_START/END/CENTER/STRETCH(pos, span)`
+ *       or "auto" to place the object on the grid in the creation order of other children
+ *       `LV_GRID_AUTO_START/END/CENTER/STRETCH`
+ * @note to use grid placement the parent needs have a defined grid with `lv_obj_set_grid`
+ */
+void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->x_set = x;
+    obj->y_set = y;
+
+    bool gi = _lv_obj_is_grid_item(obj);
+
+    /*For consistency set the size to stretched if the objects is stretched on the grid*/
+    if(gi) {
+        if(_GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
+        if(_GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
+    }
+
+    /*If not grid item but has grid position set the position to 0*/
+    if(!gi) {
+        if(_GRID_IS_CELL(x)) {
+            obj->x_set = 0;
+            x = 0;
+        }
+        if(_GRID_IS_CELL(y)) {
+            obj->y_set = 0;
+            y = 0;
+        }
+    }
+
+    /*If the object is on a grid item let the grid to position it. */
+    if(gi) {
+        lv_area_t old_area;
+        lv_area_copy(&old_area, &obj->coords);
+        lv_grid_item_refr_pos(obj);
+
+        lv_obj_t * cont = lv_obj_get_parent(obj);
+
+        /*If the item was moved and grid is implicit in the changed direction refresh the whole grid.*/
+        if((cont->grid->col_dsc == NULL && (old_area.x1 != obj->coords.x1 || old_area.x2 != obj->coords.x2)) ||
+           (cont->grid->row_dsc == NULL && (old_area.y1 != obj->coords.y1 || old_area.y2 != obj->coords.y2)))
+        {
+            lv_grid_full_refr(cont);
+        }
+    } else {
+        _lv_obj_move_to(obj, x, y, true);
+    }
+}
+
+/**
+ * Set the x coordinate of a object
+ * @param obj pointer to an object
+ * @param x new distance from the left side from the parent plus the parent's left padding or a grid cell
+ */
+void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
+}
+
+/**
+ * Set the y coordinate of a object
+ * @param obj pointer to an object
+ * @param y new distance from the top of the parent  plus the parent's top padding or a grid cell
+ */
+void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
+}
+
+/**
+ * Set the size of an object.
+ * @param obj pointer to an object
+ * @param w new width in pixels or `LV_SIZE_AUTO` to set the size to involve all children
+ * @param h new height  in pixels or `LV_SIZE_AUTO` to set the size to involve all children
+ */
+void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    bool gi = _lv_obj_is_grid_item(obj);
+    bool x_stretch = false;
+    bool y_stretch = false;
+
+    if(gi) {
+        x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
+        y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
+        if(x_stretch) w = LV_SIZE_STRETCH;
+        if(y_stretch) h = LV_SIZE_STRETCH;
+    }
+
+    obj->w_set = w;
+    obj->h_set = h;
+
+    /*If both stretched it was already managed by the grid*/
+    if(x_stretch && y_stretch) return;
+
+    if(x_stretch) w = lv_obj_get_width(obj);
+    if(y_stretch) h = lv_obj_get_height(obj);
+
+    /*Calculate the required auto sizes*/
+    bool x_auto = obj->w_set == LV_SIZE_AUTO ? true : false;
+    bool y_auto = obj->h_set == LV_SIZE_AUTO ? true : false;
+
+    lv_coord_t auto_w;
+    lv_coord_t auto_h;
+    if(x_auto && y_auto) {
+        _lv_obj_calc_auto_size(obj, &auto_w, &auto_h);
+        w = auto_w;
+        h = auto_h;
+    }
+    else if(x_auto) {
+        _lv_obj_calc_auto_size(obj, &auto_w, NULL);
+        w = auto_w;
+    }
+    else if(y_auto) {
+        _lv_obj_calc_auto_size(obj, NULL, &auto_h);
+        h = auto_h;
+    }
+
+    refr_size(obj, w, h);
+}
+
+/**
+ * Set the width of an object
+ * @param obj pointer to an object
+ * @param w new width in pixels or `LV_SIZE_AUTO` to set the size to involve all children
+ */
+void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_size(obj, w, lv_obj_get_height(obj));
+}
+
+/**
+ * Set the height of an object
+ * @param obj pointer to an object
+ * @param h new height in pixels or `LV_SIZE_AUTO` to set the size to involve all children
+ */
+void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_set_size(obj, lv_obj_get_width(obj), h);
+}
+
+/**
+ * Set the width reduced by the left and right padding.
+ * @param obj pointer to an object
+ * @param w the width without paddings in pixels
+ */
+void lv_obj_set_content_width(lv_obj_t * obj, lv_coord_t w)
+{
+    lv_style_int_t pleft = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t pright = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+
+    lv_obj_set_width(obj, w + pleft + pright);
+}
+
+/**
+ * Set the height reduced by the top and bottom padding.
+ * @param obj pointer to an object
+ * @param h the height without paddings in pixels
+ */
+void lv_obj_set_content_height(lv_obj_t * obj, lv_coord_t h)
+{
+    lv_style_int_t ptop = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t pbottom = lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+
+    lv_obj_set_height(obj, h + ptop + pbottom);
+}
+
+/**
+ * Set the width of an object by taking the left and right margin into account.
+ * The object width will be `obj_w = w - margin_left - margin_right`
+ * @param obj pointer to an object
+ * @param w new height including margins in pixels
+ */
+void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w)
+{
+    lv_style_int_t mleft = lv_obj_get_style_margin_left(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t mright = lv_obj_get_style_margin_right(obj, LV_OBJ_PART_MAIN);
+
+    lv_obj_set_width(obj, w - mleft - mright);
+}
+
+/**
+ * Set the height of an object by taking the top and bottom margin into account.
+ * The object height will be `obj_h = h - margin_top - margin_bottom`
+ * @param obj pointer to an object
+ * @param h new height including margins in pixels
+ */
+void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h)
+{
+    lv_style_int_t mtop = lv_obj_get_style_margin_top(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(obj, LV_OBJ_PART_MAIN);
+
+    lv_obj_set_height(obj, h - mtop - mbottom);
+}
+
+/**
+ * Align an object to an other object.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(base == NULL) base = lv_obj_get_parent(obj);
+
+    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
+
+    lv_point_t new_pos;
+    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
+
+    /*Bring together the coordination system of base and obj*/
+    lv_obj_t * par        = lv_obj_get_parent(obj);
+    lv_coord_t par_abs_x  = par->coords.x1;
+    lv_coord_t par_abs_y  = par->coords.y1;
+    new_pos.x += x_ofs;
+    new_pos.y += y_ofs;
+    new_pos.x -= par_abs_x;
+    new_pos.y -= par_abs_y;
+
+    lv_obj_set_pos(obj, new_pos.x, new_pos.y);
+}
+
+
+/**
+ * Copy the coordinates of an object to an area
+ * @param obj pointer to an object
+ * @param coords_out pointer to an area to store the coordinates
+ */
+void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * coords_out)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_area_copy(coords_out, &obj->coords);
+}
+
+/**
+ * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
+ * (Without the size of the border or other extra graphical elements)
+ * @param coords_out store the result area here
+ */
+void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_out)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_border_side_t part = lv_obj_get_style_border_side(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t w = lv_obj_get_style_border_width(obj, LV_OBJ_PART_MAIN);
+
+    if(part & LV_BORDER_SIDE_LEFT) coords_out->x1 += w;
+    if(part & LV_BORDER_SIDE_RIGHT) coords_out->x2 -= w;
+    if(part & LV_BORDER_SIDE_TOP) coords_out->y1 += w;
+    if(part & LV_BORDER_SIDE_BOTTOM) coords_out->y2 -= w;
+}
+
+/**
+ * Get the x coordinate of object.
+ * @param obj pointer to an object
+ * @return distance of 'obj' from the left side of its parent plus the parent's left padding
+ * @note Zero return value means the object is on the left padding of the parent, and not on the left edge.
+ * @note Scrolling of the parent doesn't change the returned value.
+ * @note The returned value is always the distance from the parent even if the position is grid cell or other special value.
+ */
+lv_coord_t lv_obj_get_x(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t rel_x;
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        rel_x   = obj->coords.x1 - parent->coords.x1;
+        rel_x += lv_obj_get_scroll_left(parent);
+        rel_x -= lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
+    }
+    else {
+        rel_x = obj->coords.x1;
+    }
+    return rel_x;
+}
+
+/**
+ * Get the y coordinate of object.
+ * @param obj pointer to an object
+ * @return distance of 'obj' from the top side of its parent plus the parent's top padding
+ * @note Zero return value means the object is on the top padding of the parent, and not on the top edge.
+ * @note Scrolling of the parent doesn't change the returned value.
+ * @note The returned value is always the distance from the parent even if the position is grid cell or other special value.
+ */
+lv_coord_t lv_obj_get_y(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t rel_y;
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        rel_y = obj->coords.y1 - parent->coords.y1;
+        rel_y += lv_obj_get_scroll_top(parent);
+        rel_y -= lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
+    }
+    else {
+        rel_y = obj->coords.y1;
+    }
+    return rel_y;
+}
+
+/**
+ * Get the width of an object
+ * @param obj pointer to an object
+ * @return the width in pixels
+ * @note The returned value is always the width in pixels even if the width is set to `LV_SIZE_AUTO` or other special value.
+ */
+lv_coord_t lv_obj_get_width(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    return lv_area_get_width(&obj->coords);
+}
+
+/**
+ * Get the height of an object
+ * @param obj pointer to an object
+ * @return the height in pixels
+ * @note The returned value is always the width in pixels even if the width is set to `LV_SIZE_AUTO` or other special value.
+ */
+lv_coord_t lv_obj_get_height(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    return lv_area_get_height(&obj->coords);
+}
+
+/**
+ * Get that width reduced by the left and right padding.
+ * @param obj pointer to an object
+ * @return the width which still fits into the container without causing overflow
+ */
+lv_coord_t lv_obj_get_width_fit(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_style_int_t left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+
+    return lv_obj_get_width(obj) - left - right;
+}
+
+/**
+ * Get that height reduced by the top an bottom padding.
+ * @param obj pointer to an object
+ * @return the height which still fits into the container without causing overflow
+ */
+lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_style_int_t top = lv_obj_get_style_pad_top((lv_obj_t *)obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t bottom =  lv_obj_get_style_pad_bottom((lv_obj_t *)obj, LV_OBJ_PART_MAIN);
+
+    return lv_obj_get_height(obj) - top - bottom;
+}
+
+/**
+ * Get the height of an object by taking the top and bottom margin into account.
+ * The returned height will be `obj_h + margin_top + margin_bottom`
+ * @param obj pointer to an object
+ * @return the height including the margins
+ */
+lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj)
+{
+    lv_style_int_t mtop = lv_obj_get_style_margin_top(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(obj, LV_OBJ_PART_MAIN);
+
+    return lv_obj_get_height(obj) + mtop + mbottom;
+}
+
+/**
+ * Get the width of an object by taking the left and right margin into account.
+ * The returned width will be `obj_w + margin_left + margin_right`
+ * @param obj pointer to an object
+ * @return the height including the margins
+ */
+lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
+{
+    lv_style_int_t mleft = lv_obj_get_style_margin_left(obj, LV_OBJ_PART_MAIN);
+    lv_style_int_t mright = lv_obj_get_style_margin_right(obj, LV_OBJ_PART_MAIN);
+
+    return lv_obj_get_width(obj) + mleft + mright;
+}
+
+/**
+ * Check if a given screen-space point is on an object's coordinates.
+ *
+ * This method is intended to be used mainly by advanced hit testing algorithms to check
+ * whether the point is even within the object (as an optimization).
+ * @param obj object to check
+ * @param point screen-space point
+ */
+bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point)
+{
+#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
+    lv_area_t ext_area;
+    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad_hor;
+    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad_hor;
+    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad_ver;
+    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad_ver;
+
+    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
+#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
+    lv_area_t ext_area;
+    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
+    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
+    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
+    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
+
+    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
+#else
+    if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
+#endif
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
+ * @param obj pointer to an object
+ * @param w_out store the width here. NULL to not calculate width
+ * @param h_out store the height here. NULL to not calculate height
+ */
+void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_out)
+{
+    if(!w_out && !h_out) return;
+
+    /*If no other effect the auto-size of zero by default*/
+    if(w_out) *w_out = 0;
+    if(h_out) *h_out = 0;
+
+    /*Get the grid size of the object has a defined grid*/
+    lv_coord_t grid_w = 0;
+    lv_coord_t grid_h = 0;
+    if(obj->grid) {
+        _lv_grid_calc_t calc;
+        grid_calc(obj, &calc);
+        grid_w = calc.col_dsc[calc.col_dsc_len - 1] + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+        grid_h = calc.row_dsc[calc.row_dsc_len - 1] + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);;
+        grid_calc_free(&calc);
+    }
+
+    /*Get the children's most right and bottom position*/
+    lv_coord_t children_w = 0;
+    lv_coord_t children_h = 0;
+    if(w_out) {
+        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
+        children_w = lv_obj_get_width(obj) + scroll_right;
+    }
+
+    if(h_out) {
+        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
+        children_h = lv_obj_get_height(obj) + scroll_bottom;
+    }
+
+
+    /*auto_size = max(gird_size, children_size)*/
+    if(w_out) *w_out = LV_MATH_MAX(children_w, grid_w);
+    if(h_out) *h_out = LV_MATH_MAX(children_h, grid_h);
+}
+
+/**
+ * Move an object to a given x and y coordinate.
+ * It's the core function to move objects but user should use `lv_obj_set_pos/x/y/..` etc.
+ * @param obj pointer to an object to move
+ * @param x the new x coordinate in pixels
+ * @param y the new y coordinate in pixels
+ * @param notify_parent true: send `LV_SIGNAL_CHILD_CHG` to the parent if `obj` moved; false: do not notify the parent
+ */
+void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent)
+{
+    /*Convert x and y to absolute coordinates*/
+    lv_obj_t * parent = obj->parent;
+
+    if(parent) {
+        lv_coord_t pad_left = lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
+        lv_coord_t pad_top = lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
+
+        x += pad_left + parent->coords.x1 - lv_obj_get_scroll_left(parent);
+        y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
+    } else {
+        /*If no parent then it's screen but screen can't be on a grid*/
+        if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
+            obj->x_set = 0;
+            obj->y_set = 0;
+            x = 0;
+            y = 0;
+        }
+    }
+
+    /*Calculate and set the movement*/
+    lv_point_t diff;
+    diff.x = x - obj->coords.x1;
+    diff.y = y - obj->coords.y1;
+
+    /* Do nothing if the position is not changed */
+    /* It is very important else recursive positioning can
+     * occur without position change*/
+    if(diff.x == 0 && diff.y == 0) return;
+
+    /*Invalidate the original area*/
+    lv_obj_invalidate(obj);
+
+    /*Save the original coordinates*/
+    lv_area_t ori;
+    lv_obj_get_coords(obj, &ori);
+
+    obj->coords.x1 += diff.x;
+    obj->coords.y1 += diff.y;
+    obj->coords.x2 += diff.x;
+    obj->coords.y2 += diff.y;
+
+    _lv_obj_move_children_by(obj, diff.x, diff.y);
+
+    /*Inform the object about its new coordinates*/
+    obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
+
+    /*Send a signal to the parent too*/
+    if(parent && notify_parent) parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
+
+    /*Invalidate the new area*/
+    lv_obj_invalidate(obj);
+}
+
+
+/**
+ * Reposition the children of an object. (Called recursively)
+ * @param obj pointer to an object which children will be repositioned
+ * @param x_diff x coordinate shift
+ * @param y_diff y coordinate shift
+ */
+void _lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff)
+{
+    lv_obj_t * i;
+    _LV_LL_READ(obj->child_ll, i) {
+        i->coords.x1 += x_diff;
+        i->coords.y1 += y_diff;
+        i->coords.x2 += x_diff;
+        i->coords.y2 += y_diff;
+
+        _lv_obj_move_children_by(i, x_diff, y_diff);
+    }
+}
+
+/**
+ * Check if an object is valid grid item or not.
+ * @param obj pointer to an object to check
+ * @return true: grid item; false: not grid item
+ */
+bool _lv_obj_is_grid_item(lv_obj_t * obj)
+{
+    lv_obj_t * cont = lv_obj_get_parent(obj);
+    if(cont == NULL) return false;
+    if(cont->grid == NULL) return false;
+    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->y_set)) return true;
+    return false;
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Set the size of an object.
+ * It's the core function to set the size of objects but user should use `lv_obj_set_size/width/height/..` etc.
+ * @param obj pointer to an object
+ * @param w the new width in pixels
+ * @param h the new height in pixels
+ * @return true: the size was changed; false: `w` and `h` was equal to the current width and height so nothing happened.
+ */
+static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
+{
+    /* Do nothing if the size is not changed */
+    /* It is very important else recursive resizing can
+     * occur without size change*/
+    if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
+        return false;
+    }
+    /*Invalidate the original area*/
+    lv_obj_invalidate(obj);
+
+    /*Save the original coordinates*/
+    lv_area_t ori;
+    lv_obj_get_coords(obj, &ori);
+
+    /*Set the length and height*/
+    obj->coords.y2 = obj->coords.y1 + h - 1;
+    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
+        obj->coords.x1 = obj->coords.x2 - w + 1;
+    }
+    else {
+        obj->coords.x2 = obj->coords.x1 + w - 1;
+    }
+
+    /*Send a signal to the object with its new coordinates*/
+    obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
+
+    /*Send a signal to the parent too*/
+    lv_obj_t * par = lv_obj_get_parent(obj);
+    if(par != NULL) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
+
+    /*Invalidate the new area*/
+    lv_obj_invalidate(obj);
+    return true;
+}
+
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
new file mode 100644
index 000000000..d7363c5e4
--- /dev/null
+++ b/src/lv_core/lv_obj_pos.h
@@ -0,0 +1,241 @@
+/**
+ * @file lv_obj_pos.h
+ *
+ */
+
+#ifndef LV_OBJ_POS_H
+#define LV_OBJ_POS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/* Can't include lv_obj.h because it includes this header file */
+struct _lv_obj_t;
+typedef struct _lv_obj_t lv_obj_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Set relative the position of an object (relative to the parent)
+ * @param obj pointer to an object
+ * @param x new distance from the left side of the parent
+ * @param y new distance from the top of the parent
+ */
+void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Set the x coordinate of a object
+ * @param obj pointer to an object
+ * @param x new distance from the left side from the parent
+ */
+void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x);
+
+/**
+ * Set the y coordinate of a object
+ * @param obj pointer to an object
+ * @param y new distance from the top of the parent
+ */
+void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y);
+
+
+void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h);
+
+/**
+ * Set the size of an object
+ * @param obj pointer to an object
+ * @param w new width
+ * @param h new height
+ */
+void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h);
+
+/**
+ * Set the width of an object
+ * @param obj pointer to an object
+ * @param w new width
+ */
+void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w);
+
+/**
+ * Set the height of an object
+ * @param obj pointer to an object
+ * @param h new height
+ */
+void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h);
+
+/**
+ * Set the width reduced by the left and right padding.
+ * @param obj pointer to an object
+ * @param w the width without paddings
+ */
+void lv_obj_set_content_width(lv_obj_t * obj, lv_coord_t w);
+
+/**
+ * Set the height reduced by the top and bottom padding.
+ * @param obj pointer to an object
+ * @param h the height without paddings
+ */
+void lv_obj_set_content_height(lv_obj_t * obj, lv_coord_t h);
+
+/**
+ * Set the width of an object by taking the left and right margin into account.
+ * The object width will be `obj_w = w - margin_left - margin_right`
+ * @param obj pointer to an object
+ * @param w new height including margins
+ */
+void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w);
+
+/**
+ * Set the height of an object by taking the top and bottom margin into account.
+ * The object height will be `obj_h = h - margin_top - margin_bottom`
+ * @param obj pointer to an object
+ * @param h new height including margins
+ */
+void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
+
+/**
+ * Align an object to an other object.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
+
+
+/**
+ * Copy the coordinates of an object to an area
+ * @param obj pointer to an object
+ * @param cords_p pointer to an area to store the coordinates
+ */
+void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * cords_p);
+
+/**
+ * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
+ * (Without the size of the border or other extra graphical elements)
+ * @param coords_p store the result area here
+ */
+void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p);
+
+/**
+ * Get the x coordinate of object
+ * @param obj pointer to an object
+ * @return distance of 'obj' from the left side of its parent
+ */
+lv_coord_t lv_obj_get_x(const lv_obj_t * obj);
+
+/**
+ * Get the y coordinate of object
+ * @param obj pointer to an object
+ * @return distance of 'obj' from the top of its parent
+ */
+lv_coord_t lv_obj_get_y(const lv_obj_t * obj);
+
+/**
+ * Get the width of an object
+ * @param obj pointer to an object
+ * @return the width
+ */
+lv_coord_t lv_obj_get_width(const lv_obj_t * obj);
+
+/**
+ * Get the height of an object
+ * @param obj pointer to an object
+ * @return the height
+ */
+lv_coord_t lv_obj_get_height(const lv_obj_t * obj);
+
+/**
+ * Get that width reduced by the left and right padding.
+ * @param obj pointer to an object
+ * @return the width which still fits into the container
+ */
+lv_coord_t lv_obj_get_width_fit(const lv_obj_t * obj);
+
+/**
+ * Get that height reduced by the top an bottom padding.
+ * @param obj pointer to an object
+ * @return the height which still fits into the container
+ */
+lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj);
+
+/**
+ * Get the height of an object by taking the top and bottom margin into account.
+ * The returned height will be `obj_h + margin_top + margin_bottom`
+ * @param obj pointer to an object
+ * @return the height including thee margins
+ */
+lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj);
+
+/**
+ * Get the width of an object by taking the left and right margin into account.
+ * The returned width will be `obj_w + margin_left + margin_right`
+ * @param obj pointer to an object
+ * @return the height including thee margins
+ */
+lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj);
+
+
+/**
+ * Check if a given screen-space point is on an object's coordinates.
+ *
+ * This method is intended to be used mainly by advanced hit testing algorithms to check
+ * whether the point is even within the object (as an optimization).
+ * @param obj object to check
+ * @param point screen-space point
+ */
+bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point);
+
+/**
+ * Divide the width of the object and get the width of a given number of columns.
+ * Take paddings into account.
+ * @param obj pointer to an object
+ * @param div indicates how many columns are assumed.
+ * If 1 the width will be set the the parent's width
+ * If 2 only half parent width - inner padding of the parent
+ * If 3 only third parent width - 2 * inner padding of the parent
+ * @param span how many columns are combined
+ * @return the width according to the given parameters
+ */
+lv_coord_t lv_obj_get_width_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
+
+/**
+ * Divide the height of the object and get the width of a given number of columns.
+ * Take paddings into account.
+ * @param obj pointer to an object
+ * @param div indicates how many rows are assumed.
+ * If 1 the height will be set the the parent's height
+ * If 2 only half parent height - inner padding of the parent
+ * If 3 only third parent height - 2 * inner padding of the parent
+ * @param span how many rows are combined
+ * @return the height according to the given parameters
+ */
+lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
+
+void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_OBJ_POS_H*/
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
new file mode 100644
index 000000000..4d94a5ba0
--- /dev/null
+++ b/src/lv_core/lv_obj_scroll.c
@@ -0,0 +1,246 @@
+/**
+ * @file lv_obj_scroll.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_scroll.h"
+#include "lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define SCROLL_ANIM_TIME_MIN 100    /*ms*/
+#define SCROLL_ANIM_TIME_MAX 300    /*ms*/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v);
+static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Set how the scrollbars should behave.
+ * @param obj pointer to an object
+ * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(obj->scroll_mode == mode) return;
+    obj->scroll_mode = mode;
+    lv_obj_invalidate(obj);
+}
+
+/**
+ * Get how the scrollbars should behave.
+ * @param obj pointer to an object
+ * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    return obj->scroll_mode;
+}
+
+/**
+ * Moves all children with horizontally or vertically.
+ * It doesn't take into account any limits so any values are possible
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
+{
+    obj->scroll.x += x;
+    obj->scroll.y += y;
+
+    _lv_obj_move_children_by(obj, x, y);
+    lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
+    if(res != LV_RES_OK) return;
+    lv_obj_invalidate(obj);
+}
+/**
+ * Moves all children with horizontally or vertically.
+ * Limits the scroll to the bounding box of the children.
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+    if(x == 0 && y == 0) return;
+
+    if(anim_en == LV_ANIM_ON) {
+        lv_disp_t * d = lv_obj_get_disp(obj);
+        lv_anim_t a;
+        lv_anim_init(&a);
+        lv_anim_set_var(&a, obj);
+
+        lv_anim_path_t path;
+        lv_anim_path_init(&path);
+        lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
+
+        if(x) {
+            uint32_t t = lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 3) >> 2, 0, x);
+            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
+            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
+            lv_anim_set_time(&a, t);
+            lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
+            lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
+            lv_anim_set_path(&a, &path);
+            lv_anim_start(&a);
+        }
+
+        if(y) {
+            uint32_t t = lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 3) >> 2, 0, y);
+            if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
+            if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
+            lv_anim_set_time(&a, t);
+            lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
+            lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
+            lv_anim_set_path(&a, &path);
+            lv_anim_start(&a);
+        }
+    } else {
+        _lv_obj_scroll_by_raw(obj, x, y);
+    }
+}
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+
+}
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ */
+void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
+{
+    lv_obj_scroll_by(obj, -x - obj->scroll.x, 0, anim_en);
+}
+
+/**
+ * Scroll the a given y coordinate to the top side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
+{
+    lv_obj_scroll_by(obj, 0,  -y - obj->scroll.y, anim_en);
+}
+
+
+/**
+ * Return the height of the area above the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
+{
+    return -obj->scroll.y;
+}
+
+/**
+ * Return the height of the area below the parent.
+ * That is the number of pixels the object can be scrolled up.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t y2 = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child == NULL) return 0;
+
+    while(child) {
+        y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return y2 - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+}
+
+/**
+ * Return the weight of the area on the left the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
+{
+    return -obj->scroll.x;
+}
+
+/**
+ * Return the width of the area below the object.
+ * That is the number of pixels the object can be scrolled left.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t x2 = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child == NULL) return 0;
+
+    while(child) {
+        x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return x2 - obj->coords.x2  + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
+{
+    _lv_obj_scroll_by_raw(obj, v - obj->scroll.x, 0);
+}
+
+static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
+{
+    _lv_obj_scroll_by_raw(obj, 0, v - obj->scroll.y);
+}
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
new file mode 100644
index 000000000..fa5ab753d
--- /dev/null
+++ b/src/lv_core/lv_obj_scroll.h
@@ -0,0 +1,153 @@
+/**
+ * @file lv_obj_scroll.h
+ *
+ */
+
+#ifndef LV_OBJ_SCROLL_H
+#define LV_OBJ_SCROLL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_misc/lv_area.h"
+#include "../lv_misc/lv_anim.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_obj_t;
+typedef struct _lv_obj_t lv_obj_t;
+
+/** Scrollbar modes: shows when should the scrollbars be visible*/
+enum {
+    LV_SCROLL_MODE_OFF    = 0x0, /**< Never show scroll bars*/
+    LV_SCROLL_MODE_ON     = 0x1, /**< Always show scroll bars*/
+    LV_SCROLL_MODE_ACTIVE = 0x2, /**< Show scroll bars when object is being scrolled*/
+    LV_SCROLL_MODE_AUTO   = 0x3, /**< Show scroll bars when the content is large enough to be scrolled*/
+};
+typedef uint8_t lv_scroll_mode_t;
+
+
+enum {
+    LV_SCROLL_SNAP_ALIGN_NONE,
+    LV_SCROLL_SNAP_ALIGN_START,
+    LV_SCROLL_SNAP_ALIGN_END,
+    LV_SCROLL_SNAP_ALIGN_CENTER
+};
+typedef uint8_t lv_scroll_snap_align_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Set how the scrollbars should behave.
+ * @param obj pointer to an object
+ * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode);
+
+/**
+ * Get how the scrollbars should behave.
+ * @param obj pointer to an object
+ * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
+ */
+lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj);
+
+/**
+ * Moves all children with horizontally or vertically.
+ * It doesn't take into account any limits so any values are possible
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Moves all children with horizontally or vertically.
+ * Limits the scroll to the bounding box of the children.
+ * @param obj pointer to an object whose children should be moved
+ * @param x pixel to move horizontally
+ * @param y pixels to move vertically
+ */
+void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given x coordinate to the left side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param x the x coordinate to scroll to
+ */
+void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll the a given y coordinate to the top side of obj.
+ * @param obj pointer to an object which should be scrolled
+ * @param y the y coordinate to scroll to
+ */
+void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
+
+
+/**
+ * Return the height of the area above the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj);
+
+/**
+ * Return the height of the area below the parent.
+ * That is the number of pixels the object can be scrolled up.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
+
+
+/**
+ * Return the weight of the area on the left the parent.
+ * That is the number of pixels the object can be scrolled down.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj);
+
+/**
+ * Return the width of the area below the object.
+ * That is the number of pixels the object can be scrolled left.
+ * Normally positive but can be negative when scrolled inside.
+ * @param obj
+ * @return
+ */
+lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_OBJ_SCROLL_H*/
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
new file mode 100644
index 000000000..9fa0be8b9
--- /dev/null
+++ b/src/lv_core/lv_obj_style.c
@@ -0,0 +1,1366 @@
+/**
+ * @file lv_obj_style.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj.h"
+#include "lv_disp.h"
+#include "../lv_themes/lv_theme.h"
+#include "../lv_misc/lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+    #include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_obj_t * obj;
+    lv_style_property_t prop;
+    uint8_t part;
+    union {
+        lv_color_t _color;
+        lv_style_int_t _int;
+        lv_opa_t _opa;
+        const void * _ptr;
+    } start_value;
+    union {
+        lv_color_t _color;
+        lv_style_int_t _int;
+        lv_opa_t _opa;
+        const void * _ptr;
+    } end_value;
+} lv_style_trans_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void report_style_change_core(void * style, lv_obj_t * obj);
+static void refresh_children_style(lv_obj_t * obj);
+#if LV_USE_ANIMATION
+static void trans_del(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_trans_t * tr_limit);
+static void trans_anim_cb(lv_style_trans_t * tr, lv_anim_value_t v);
+static void trans_anim_start_cb(lv_anim_t * a);
+static void trans_anim_ready_cb(lv_anim_t * a);
+#endif
+
+static bool style_prop_is_cacheable(lv_style_property_t prop);
+static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop);
+static void update_style_cache_children(lv_obj_t * obj);
+static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+static void fade_anim_cb(lv_obj_t * obj, lv_anim_value_t v);
+static void fade_in_anim_ready(lv_anim_t * a);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the object related style manager module.
+ * Called by LVGL in `lv_init()`
+ */
+void _lv_obj_style_init(void)
+{
+    _lv_ll_init(&LV_GC_ROOT(_lv_obj_style_trans_ll), sizeof(lv_style_trans_t));
+}
+
+/**
+ * Add a new style to the style list of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param style pointer to a style to add (Only its pointer will be saved)
+ */
+void lv_obj_add_style(lv_obj_t * obj, uint8_t part, lv_style_t * style)
+{
+    if(style == NULL) return;
+
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    if(list == NULL) {
+        LV_LOG_WARN("Can't find style with part: %d", part);
+        return;
+    }
+
+    _lv_style_list_add_style(list, style);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, 0xFF, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
+}
+
+/**
+ * Remove a style from the style list of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *              E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param style pointer to a style to remove
+ */
+void lv_obj_remove_style(lv_obj_t * obj, uint8_t part, lv_style_t * style)
+{
+    if(style == NULL) return;
+
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    if(list == NULL) {
+        LV_LOG_WARN("Can't find style with part: %d", part);
+        return;
+    }
+
+    _lv_style_list_remove_style(list, style);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, 0xFF, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
+}
+
+/**
+ * Reset a style to the default (empty) state.
+ * Release all used memories and cancel pending related transitions.
+ * Also notifies the object about the style change.
+ * @param obj pointer to an object
+ * @param part the part of the object which style list should be reseted.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ */
+void lv_obj_reset_style_list(lv_obj_t * obj, uint8_t part)
+{
+    _lv_obj_reset_style_list_no_refr(obj, part);
+
+    _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
+}
+
+/**
+ * Notify all object if a style is modified
+ * @param style pointer to a style. Only the objects with this style will be notified
+ *               (NULL to notify all objects)
+ */
+void lv_obj_report_style_change(lv_style_t * style)
+{
+    lv_disp_t * d = lv_disp_get_next(NULL);
+
+    while(d) {
+        lv_obj_t * i;
+        _LV_LL_READ(d->scr_ll, i) {
+            report_style_change_core(style, i);
+        }
+        d = lv_disp_get_next(d);
+    }
+}
+
+/**
+ * Remove a local style property from a part of an object with a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be removed.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @return true: the property was found and removed; false: the property was not found
+ */
+bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_style_t * style = _lv_obj_get_local_style(obj, part);
+    if(style) return lv_style_remove_prop(style, prop);
+    else return false;
+}
+
+
+#if LV_USE_ANIMATION
+/**
+ * Fade in (from transparent to fully cover) an object and all its children using an `opa_scale` animation.
+ * @param obj the object to fade in
+ * @param time duration of the animation [ms]
+ * @param delay wait before the animation starts [ms]
+ */
+void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_values(&a, LV_OPA_TRANSP, LV_OPA_COVER);
+    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)fade_anim_cb);
+    lv_anim_set_ready_cb(&a, fade_in_anim_ready);
+    lv_anim_set_time(&a, time);
+    lv_anim_set_delay(&a, delay);
+    lv_anim_start(&a);
+}
+
+/**
+ * Fade out (from fully cover to transparent) an object and all its children using an `opa_scale` animation.
+ * @param obj the object to fade in
+ * @param time duration of the animation [ms]
+ * @param delay wait before the animation starts [ms]
+ */
+void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_values(&a, LV_OPA_COVER, LV_OPA_TRANSP);
+    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)fade_anim_cb);
+    lv_anim_set_time(&a, time);
+    lv_anim_set_delay(&a, delay);
+    lv_anim_start(&a);
+}
+#endif
+
+
+/**
+ * Get the style list of part of an object
+ * @param obj pointer to an object
+ * @param part the part of the object.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @return pointer to the style list
+ */
+lv_style_list_t * _lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part)
+{
+    if(part == LV_OBJ_PART_MAIN) return &((lv_obj_t *)obj)->style_list;
+
+    lv_get_style_info_t info;
+    info.part = part;
+    info.result = NULL;
+
+    lv_res_t res;
+    res = lv_signal_send((lv_obj_t *)obj, LV_SIGNAL_GET_STYLE, &info);
+
+    if(res != LV_RES_OK) return NULL;
+
+    return info.result;
+}
+
+/**
+ * Enable/disable the use of style cache for an object
+ * @param obj pointer to an object
+ * @param dis true: disable; false: enable (re-enable)
+ */
+void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
+{
+    uint8_t part;
+    for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) break;
+        list->ignore_cache = dis;
+    }
+    for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) break;
+        list->ignore_cache = dis;
+    }
+}
+
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_WIDTH`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    lv_style_property_t prop_ori = prop;
+
+    lv_style_attr_t attr;
+    attr = prop_ori >> 8;
+
+    lv_style_int_t value_act;
+    lv_res_t res = LV_RES_INV;
+    const lv_obj_t * parent = obj;
+    while(parent) {
+        lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
+        if(!list->ignore_cache && list->style_cnt > 0) {
+            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
+
+            bool def = false;
+            switch(prop  & (~LV_STYLE_STATE_MASK)) {
+                case LV_STYLE_BG_GRAD_DIR:
+                    if(list->bg_grad_dir_none) def = true;
+                    break;
+                case LV_STYLE_CLIP_CORNER:
+                    if(list->clip_corner_off) def = true;
+                    break;
+                case LV_STYLE_TEXT_LETTER_SPACE:
+                case LV_STYLE_TEXT_LINE_SPACE:
+                    if(list->text_space_zero) def = true;
+                    break;
+                case LV_STYLE_TRANSFORM_ANGLE:
+                case LV_STYLE_TRANSFORM_WIDTH:
+                case LV_STYLE_TRANSFORM_HEIGHT:
+                case LV_STYLE_TRANSFORM_ZOOM:
+                    if(list->transform_all_zero) def = true;
+                    break;
+                case LV_STYLE_BORDER_WIDTH:
+                    if(list->border_width_zero) def = true;
+                    break;
+                case LV_STYLE_BORDER_SIDE:
+                    if(list->border_side_full) def = true;
+                    break;
+                case LV_STYLE_BORDER_POST:
+                    if(list->border_post_off) def = true;
+                    break;
+                case LV_STYLE_OUTLINE_WIDTH:
+                    if(list->outline_width_zero) def = true;
+                    break;
+                case LV_STYLE_RADIUS:
+                    if(list->radius_zero) def = true;
+                    break;
+                case LV_STYLE_SHADOW_WIDTH:
+                    if(list->shadow_width_zero) def = true;
+                    break;
+                case LV_STYLE_PAD_TOP:
+                case LV_STYLE_PAD_BOTTOM:
+                case LV_STYLE_PAD_LEFT:
+                case LV_STYLE_PAD_RIGHT:
+                    if(list->pad_all_zero) def = true;
+                    break;
+                case LV_STYLE_MARGIN_TOP:
+                case LV_STYLE_MARGIN_BOTTOM:
+                case LV_STYLE_MARGIN_LEFT:
+                case LV_STYLE_MARGIN_RIGHT:
+                    if(list->margin_all_zero) def = true;
+                    break;
+                case LV_STYLE_BG_BLEND_MODE:
+                case LV_STYLE_BORDER_BLEND_MODE:
+                case LV_STYLE_IMAGE_BLEND_MODE:
+                case LV_STYLE_LINE_BLEND_MODE:
+                case LV_STYLE_OUTLINE_BLEND_MODE:
+                case LV_STYLE_PATTERN_BLEND_MODE:
+                case LV_STYLE_SHADOW_BLEND_MODE:
+                case LV_STYLE_TEXT_BLEND_MODE:
+                case LV_STYLE_VALUE_BLEND_MODE:
+                    if(list->blend_mode_all_normal) def = true;
+                    break;
+            }
+
+            if(def) {
+                break;
+            }
+        }
+
+        lv_state_t state = lv_obj_get_state(parent, part);
+        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
+
+        res = _lv_style_list_get_int(list, prop, &value_act);
+        if(res == LV_RES_OK) return value_act;
+
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
+
+        /*If not found, check the `MAIN` style first*/
+        if(part != LV_OBJ_PART_MAIN) {
+            part = LV_OBJ_PART_MAIN;
+            continue;
+        }
+
+        /*Check the parent too.*/
+        parent = lv_obj_get_parent(parent);
+    }
+
+    /*Handle unset values*/
+    prop = prop & (~LV_STYLE_STATE_MASK);
+    switch(prop) {
+        case LV_STYLE_BORDER_SIDE:
+            return LV_BORDER_SIDE_FULL;
+        case LV_STYLE_SIZE:
+            return LV_DPI / 20;
+        case LV_STYLE_SCALE_WIDTH:
+            return LV_DPI / 8;
+        case LV_STYLE_BG_GRAD_STOP:
+            return 255;
+        case LV_STYLE_TRANSFORM_ZOOM:
+            return LV_IMG_ZOOM_NONE;
+        case LV_STYLE_SCROLLBAR_TICKNESS:
+            return LV_DPX(10);
+    }
+
+    return 0;
+}
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_COLOR`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_color()`
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    lv_style_property_t prop_ori = prop;
+
+    lv_style_attr_t attr;
+    attr = prop_ori >> 8;
+
+    lv_color_t value_act;
+    lv_res_t res = LV_RES_INV;
+    const lv_obj_t * parent = obj;
+    while(parent) {
+        lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
+
+        lv_state_t state = lv_obj_get_state(parent, part);
+        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
+
+        res = _lv_style_list_get_color(list, prop, &value_act);
+        if(res == LV_RES_OK) return value_act;
+
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
+
+        /*If not found, check the `MAIN` style first*/
+        if(part != LV_OBJ_PART_MAIN) {
+            part = LV_OBJ_PART_MAIN;
+            continue;
+        }
+
+        /*Check the parent too.*/
+        parent = lv_obj_get_parent(parent);
+    }
+
+    /*Handle unset values*/
+    prop = prop & (~LV_STYLE_STATE_MASK);
+    switch(prop) {
+        case LV_STYLE_BG_COLOR:
+        case LV_STYLE_BG_GRAD_COLOR:
+            return LV_COLOR_WHITE;
+    }
+
+    return LV_COLOR_BLACK;
+}
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_OPA`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    lv_style_property_t prop_ori = prop;
+
+    lv_style_attr_t attr;
+    attr = prop_ori >> 8;
+
+    lv_opa_t value_act;
+    lv_res_t res = LV_RES_INV;
+    const lv_obj_t * parent = obj;
+    while(parent) {
+        lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
+
+        if(!list->ignore_cache && list->style_cnt > 0) {
+            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
+            bool def = false;
+            switch(prop & (~LV_STYLE_STATE_MASK)) {
+                case LV_STYLE_OPA_SCALE:
+                    if(list->opa_scale_cover) def = true;
+                    break;
+                case LV_STYLE_BG_OPA:
+                    if(list->bg_opa_cover) return LV_OPA_COVER;     /*Special case, not the default value is used*/
+                    if(list->bg_opa_transp) def = true;
+                    break;
+                case LV_STYLE_IMAGE_RECOLOR_OPA:
+                    if(list->img_recolor_opa_transp) def = true;
+                    break;
+            }
+
+            if(def) {
+                break;
+            }
+        }
+
+
+        lv_state_t state = lv_obj_get_state(parent, part);
+        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
+
+        res = _lv_style_list_get_opa(list, prop, &value_act);
+        if(res == LV_RES_OK) return value_act;
+
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
+
+        /*If not found, check the `MAIN` style first*/
+        if(part != LV_OBJ_PART_MAIN) {
+            part = LV_OBJ_PART_MAIN;
+            continue;
+        }
+
+        /*Check the parent too.*/
+        parent = lv_obj_get_parent(parent);
+    }
+
+    /*Handle unset values*/
+    prop = prop & (~LV_STYLE_STATE_MASK);
+    switch(prop) {
+        case LV_STYLE_BG_OPA:
+        case LV_STYLE_IMAGE_RECOLOR_OPA:
+        case LV_STYLE_PATTERN_RECOLOR_OPA:
+            return LV_OPA_TRANSP;
+    }
+
+    return LV_OPA_COVER;
+}
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_TEXT_FONT`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    lv_style_property_t prop_ori = prop;
+
+    lv_style_attr_t attr;
+    attr = prop_ori >> 8;
+
+    const void * value_act;
+    lv_res_t res = LV_RES_INV;
+    const lv_obj_t * parent = obj;
+    while(parent) {
+        lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
+
+        if(!list->ignore_cache && list->style_cnt > 0) {
+            if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
+            bool def = false;
+            switch(prop  & (~LV_STYLE_STATE_MASK)) {
+                case LV_STYLE_VALUE_STR:
+                    if(list->value_txt_str) def = true;
+                    break;
+                case LV_STYLE_PATTERN_IMAGE:
+                    if(list->pattern_img_null) def = true;
+                    break;
+                case LV_STYLE_TEXT_FONT:
+                    if(list->text_font_normal) def = true;
+                    break;
+            }
+
+            if(def) {
+                break;
+            }
+        }
+
+        lv_state_t state = lv_obj_get_state(parent, part);
+        prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
+
+        res = _lv_style_list_get_ptr(list, prop, &value_act);
+        if(res == LV_RES_OK)  return value_act;
+
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
+
+        /*If not found, check the `MAIN` style first*/
+        if(part != LV_OBJ_PART_MAIN) {
+            part = LV_OBJ_PART_MAIN;
+            continue;
+        }
+
+        /*Check the parent too.*/
+        parent = lv_obj_get_parent(parent);
+    }
+
+    /*Handle unset values*/
+    prop = prop & (~LV_STYLE_STATE_MASK);
+    switch(prop) {
+        case LV_STYLE_TEXT_FONT:
+        case LV_STYLE_VALUE_FONT:
+            return lv_theme_get_font_normal();
+#if LV_USE_ANIMATION
+        case LV_STYLE_TRANSITION_PATH:
+            return &lv_anim_path_def;
+#endif
+    }
+
+    return NULL;
+}
+
+/**
+ * Get the local style of a part of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @return pointer to the local style if exists else `NULL`.
+ */
+lv_style_t * _lv_obj_get_local_style(lv_obj_t * obj, uint8_t part)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+    lv_style_list_t * style_list = _lv_obj_get_style_list(obj, part);
+    return lv_style_list_get_local_style(style_list);
+}
+
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *              E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+void _lv_obj_set_style_local_int(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_int_t value)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    _lv_style_list_set_local_int(list, prop, value);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, prop, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
+}
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+void _lv_obj_set_style_local_color(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_color_t color)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    _lv_style_list_set_local_color(list, prop, color);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, prop, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
+}
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+void _lv_obj_set_style_local_opa(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_opa_t opa)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    _lv_style_list_set_local_opa(list, prop, opa);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, prop, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
+}
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, const void * value)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    _lv_style_list_set_local_ptr(list, prop, value);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, prop, NULL);
+#endif
+    _lv_obj_refresh_style(obj, part, prop & (~LV_STYLE_STATE_MASK));
+}
+
+/**
+ * Reset a style to the default (empty) state.
+ * Release all used memories and cancel pending related transitions.
+ * Typically used in `LV_SIGNAL_CLEAN_UP.
+ * @param obj pointer to an object
+ * @param part the part of the object which style list should be reseted.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ */
+void _lv_obj_reset_style_list_no_refr(lv_obj_t * obj, uint8_t part)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+    if(list == NULL) {
+        LV_LOG_WARN("_lv_obj_reset_style_list_no_refr: can't find style with `part`");
+        return;
+    }
+
+    _lv_style_list_reset(list);
+#if LV_USE_ANIMATION
+    trans_del(obj, part, 0xFF, NULL);
+#endif
+}
+
+
+/**
+ * Notify an object and its children about its style is modified
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be refreshed.
+ * @param prop `LV_STYLE_PROP_ALL` or an `LV_STYLE_...` property. It is used to optimize what needs to be refreshed.
+ */
+void _lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    invalidate_style_cache(obj, part, prop);
+
+    /*If a real style refresh is required*/
+    bool real_refr = false;
+    switch(prop) {
+        case LV_STYLE_PROP_ALL:
+        case LV_STYLE_CLIP_CORNER:
+        case LV_STYLE_SIZE:
+        case LV_STYLE_TRANSFORM_WIDTH:
+        case LV_STYLE_TRANSFORM_HEIGHT:
+        case LV_STYLE_TRANSFORM_ANGLE:
+        case LV_STYLE_TRANSFORM_ZOOM:
+        case LV_STYLE_PAD_TOP:
+        case LV_STYLE_PAD_BOTTOM:
+        case LV_STYLE_PAD_LEFT:
+        case LV_STYLE_PAD_RIGHT:
+        case LV_STYLE_PAD_INNER:
+        case LV_STYLE_MARGIN_TOP:
+        case LV_STYLE_MARGIN_BOTTOM:
+        case LV_STYLE_MARGIN_LEFT:
+        case LV_STYLE_MARGIN_RIGHT:
+        case LV_STYLE_OUTLINE_WIDTH:
+        case LV_STYLE_OUTLINE_PAD:
+        case LV_STYLE_OUTLINE_OPA:
+        case LV_STYLE_SHADOW_WIDTH:
+        case LV_STYLE_SHADOW_OPA:
+        case LV_STYLE_SHADOW_OFS_X:
+        case LV_STYLE_SHADOW_OFS_Y:
+        case LV_STYLE_SHADOW_SPREAD:
+        case LV_STYLE_VALUE_LETTER_SPACE:
+        case LV_STYLE_VALUE_LINE_SPACE:
+        case LV_STYLE_VALUE_OFS_X:
+        case LV_STYLE_VALUE_OFS_Y:
+        case LV_STYLE_VALUE_ALIGN:
+        case LV_STYLE_VALUE_STR:
+        case LV_STYLE_VALUE_FONT:
+        case LV_STYLE_VALUE_OPA:
+        case LV_STYLE_TEXT_LETTER_SPACE:
+        case LV_STYLE_TEXT_LINE_SPACE:
+        case LV_STYLE_TEXT_FONT:
+        case LV_STYLE_LINE_WIDTH:
+            real_refr = true;
+            break;
+        default:
+            real_refr = false;
+    }
+
+    if(real_refr) {
+        lv_obj_invalidate(obj);
+        obj->signal_cb(obj, LV_SIGNAL_STYLE_CHG, NULL);
+
+        switch(prop) {
+            case LV_STYLE_PROP_ALL:
+            case LV_STYLE_MARGIN_TOP:
+            case LV_STYLE_MARGIN_BOTTOM:
+            case LV_STYLE_MARGIN_LEFT:
+            case LV_STYLE_MARGIN_RIGHT:
+                if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, obj);
+                break;
+        }
+
+        lv_obj_invalidate(obj);
+
+        /*Send style change signals*/
+        if(prop == LV_STYLE_PROP_ALL || (prop & LV_STYLE_INHERIT_MASK)) refresh_children_style(obj);
+    }
+    else {
+        lv_obj_invalidate(obj);
+    }
+}
+
+/**
+ * Remove all transitions from an object
+ * @param obj pointer to an object
+ */
+void _lv_obj_remove_style_trans(lv_obj_t * obj)
+{
+    trans_del(obj, 0xFF, 0xFF, NULL);
+}
+
+#if LV_USE_ANIMATION
+
+/**
+ * Allocate and initialize a transition for a property of an object if the properties value is different in the new state.
+ * It allocates `lv_style_trans_t` in `_lv_obj_style_trans_ll` and set only `start/end_values`. No animation will be created here.
+ * @param obj and object to add the transition
+ * @param prop the property to apply the transaction
+ * @param part the part of the object to apply the transaction
+ * @param prev_state the previous state of the objects
+ * @param new_state the new state of the object
+ * @param time duration of transition in [ms]
+ * @param delay delay before starting the transition in [ms]
+ * @param path the path of the transition
+ * @return pointer to the allocated `the transaction` variable or `NULL` if no transition created
+ */
+void _lv_obj_create_style_transition(lv_obj_t * obj, lv_style_property_t prop, uint8_t part, lv_state_t prev_state,
+                                       lv_state_t new_state, uint32_t time, uint32_t delay, lv_anim_path_t * path)
+{
+    lv_style_trans_t * tr;
+    lv_style_list_t * style_list = _lv_obj_get_style_list(obj, part);
+    lv_style_t * style_trans = _lv_style_list_get_transition_style(style_list);
+
+    /*Get the previous and current values*/
+    if((prop & 0xF) < LV_STYLE_ID_COLOR) { /*Int*/
+        style_list->skip_trans = 1;
+        obj->state = prev_state;
+        lv_style_int_t int1 = _lv_obj_get_style_int(obj, part, prop);
+        obj->state = new_state;
+        lv_style_int_t int2 =  _lv_obj_get_style_int(obj, part, prop);
+        style_list->skip_trans = 0;
+
+        if(int1 == int2)  return;
+        obj->state = prev_state;
+        int1 = _lv_obj_get_style_int(obj, part, prop);
+        obj->state = new_state;
+        _lv_style_set_int(style_trans, prop, int1);   /*Be sure `trans_style` has a valid value */
+
+        if(prop == LV_STYLE_RADIUS) {
+            if(int1 == LV_RADIUS_CIRCLE || int2 == LV_RADIUS_CIRCLE) {
+                lv_coord_t whalf = lv_obj_get_width(obj) / 2;
+                lv_coord_t hhalf = lv_obj_get_width(obj) / 2;
+                if(int1 == LV_RADIUS_CIRCLE) int1 = LV_MATH_MIN(whalf + 1, hhalf + 1);
+                if(int2 == LV_RADIUS_CIRCLE) int2 = LV_MATH_MIN(whalf + 1, hhalf + 1);
+            }
+        }
+
+        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
+        LV_ASSERT_MEM(tr);
+        if(tr == NULL) return;
+        tr->start_value._int = int1;
+        tr->end_value._int = int2;
+    }
+    else if((prop & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
+        style_list->skip_trans = 1;
+        obj->state = prev_state;
+        lv_color_t c1 = _lv_obj_get_style_color(obj, part, prop);
+        obj->state = new_state;
+        lv_color_t c2 =  _lv_obj_get_style_color(obj, part, prop);
+        style_list->skip_trans = 0;
+
+        if(c1.full == c2.full) return;
+        obj->state = prev_state;
+        c1 = _lv_obj_get_style_color(obj, part, prop);
+        obj->state = new_state;
+        _lv_style_set_color(style_trans, prop, c1);    /*Be sure `trans_style` has a valid value */
+
+        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
+        LV_ASSERT_MEM(tr);
+        if(tr == NULL) return;
+        tr->start_value._color = c1;
+        tr->end_value._color = c2;
+    }
+    else if((prop & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
+        style_list->skip_trans = 1;
+        obj->state = prev_state;
+        lv_opa_t o1 = _lv_obj_get_style_opa(obj, part, prop);
+        obj->state = new_state;
+        lv_opa_t o2 =  _lv_obj_get_style_opa(obj, part, prop);
+        style_list->skip_trans = 0;
+
+        if(o1 == o2) return;
+
+        obj->state = prev_state;
+        o1 = _lv_obj_get_style_opa(obj, part, prop);
+        obj->state = new_state;
+        _lv_style_set_opa(style_trans, prop, o1);   /*Be sure `trans_style` has a valid value */
+
+        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
+        LV_ASSERT_MEM(tr);
+        if(tr == NULL) return;
+        tr->start_value._opa = o1;
+        tr->end_value._opa = o2;
+    }
+    else {      /*Ptr*/
+        obj->state = prev_state;
+        style_list->skip_trans = 1;
+        const void * p1 = _lv_obj_get_style_ptr(obj, part, prop);
+        obj->state = new_state;
+        const void * p2 = _lv_obj_get_style_ptr(obj, part, prop);
+        style_list->skip_trans = 0;
+
+        if(memcmp(&p1, &p2, sizeof(const void *)) == 0)  return;
+        obj->state = prev_state;
+        p1 = _lv_obj_get_style_ptr(obj, part, prop);
+        obj->state = new_state;
+        _lv_style_set_ptr(style_trans, prop, p1);   /*Be sure `trans_style` has a valid value */
+
+        tr = _lv_ll_ins_head(&LV_GC_ROOT(_lv_obj_style_trans_ll));
+        LV_ASSERT_MEM(tr);
+        if(tr == NULL) return;
+        tr->start_value._ptr = p1;
+        tr->end_value._ptr = p2;
+    }
+
+    if(tr) {
+        tr->obj = obj;
+        tr->prop = prop;
+        tr->part = part;
+
+        lv_anim_t a;
+        lv_anim_init(&a);
+        lv_anim_set_var(&a, tr);
+        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)trans_anim_cb);
+        lv_anim_set_start_cb(&a, trans_anim_start_cb);
+        lv_anim_set_ready_cb(&a, trans_anim_ready_cb);
+        lv_anim_set_values(&a, 0x00, 0xFF);
+        lv_anim_set_time(&a, time);
+        lv_anim_set_delay(&a, delay);
+        lv_anim_set_path(&a, path);
+        a.early_apply = 0;
+        lv_anim_start(&a);
+    }
+}
+
+#endif
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Refresh the style of all children of an object. (Called recursively)
+ * @param style refresh objects only with this style_list.
+ * @param obj pointer to an object
+ */
+static void report_style_change_core(void * style, lv_obj_t * obj)
+{
+    uint8_t part;
+    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) break;
+
+        uint8_t ci;
+        for(ci = 0; ci < list->style_cnt; ci++) {
+            lv_style_t * class = lv_style_list_get_style(list, ci);
+            if(class == style || style == NULL) {
+                _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
+                break;
+            }
+        }
+    }
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child) {
+        report_style_change_core(style, child);
+        child = lv_obj_get_child(obj, child);
+    }
+
+}
+
+/**
+ * Recursively refresh the style of the children. Go deeper until a not NULL style is found
+ * because the NULL styles are inherited from the parent
+ * @param obj pointer to an object
+ */
+static void refresh_children_style(lv_obj_t * obj)
+{
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child != NULL) {
+        lv_obj_invalidate(child);
+        child->signal_cb(child, LV_SIGNAL_STYLE_CHG, NULL);
+        lv_obj_invalidate(child);
+
+        refresh_children_style(child); /*Check children too*/
+        child = lv_obj_get_child(obj, child);
+    }
+}
+
+#if LV_USE_ANIMATION
+/**
+ * Remove the transition from object's part's property.
+ * - Remove the transition from `_lv_obj_style_trans_ll` and free it
+ * - Delete pending transitions
+ * @param obj pointer to an object which transition(s) should be removed
+ * @param part a part of object or 0xFF to remove from all parts
+ * @param prop a property or 0xFF to remove all properties
+ * @param tr_limit delete transitions only "older" then this. `NULL` is not used
+ */
+static void trans_del(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_trans_t * tr_limit)
+{
+    lv_style_trans_t * tr;
+    lv_style_trans_t * tr_prev;
+    tr = _lv_ll_get_tail(&LV_GC_ROOT(_lv_obj_style_trans_ll));
+    while(tr != NULL) {
+        if(tr == tr_limit) break;
+
+        /*'tr' might be deleted, so get the next object while 'tr' is valid*/
+        tr_prev = _lv_ll_get_prev(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
+
+        if(tr->obj == obj && (part == tr->part || part == 0xFF) && (prop == tr->prop || prop == 0xFF)) {
+            /* Remove the transitioned property from trans. style
+             * to allow changing it by normal styles*/
+            lv_style_list_t * list = _lv_obj_get_style_list(tr->obj, tr->part);
+            lv_style_t * style_trans = _lv_style_list_get_transition_style(list);
+            lv_style_remove_prop(style_trans, tr->prop);
+
+            lv_anim_del(tr, NULL);
+            _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
+            lv_mem_free(tr);
+        }
+        tr = tr_prev;
+    }
+}
+
+static void trans_anim_cb(lv_style_trans_t * tr, lv_anim_value_t v)
+{
+    lv_style_list_t * list = _lv_obj_get_style_list(tr->obj, tr->part);
+    lv_style_t * style = _lv_style_list_get_transition_style(list);
+
+    if((tr->prop & 0xF) < LV_STYLE_ID_COLOR) { /*Value*/
+        lv_style_int_t x;
+        if(v == 0) x = tr->start_value._int;
+        else if(v == 255) x = tr->end_value._int;
+        else x = tr->start_value._int + ((int32_t)((int32_t)(tr->end_value._int - tr->start_value._int) * v) >> 8);
+        _lv_style_set_int(style, tr->prop, x);
+    }
+    else if((tr->prop & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
+        lv_color_t x;
+        if(v <= 0) x = tr->start_value._color;
+        else if(v >= 255) x = tr->end_value._color;
+        else x = lv_color_mix(tr->end_value._color, tr->start_value._color, v);
+        _lv_style_set_color(style, tr->prop, x);
+    }
+    else if((tr->prop & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
+        lv_opa_t x;
+        if(v <= 0) x = tr->start_value._opa;
+        else if(v >= 255) x = tr->end_value._opa;
+        else x = tr->start_value._opa + (((tr->end_value._opa - tr->start_value._opa) * v) >> 8);
+        _lv_style_set_opa(style, tr->prop, x);
+    }
+    else {
+        const void * x;
+        if(v < 128) x = tr->start_value._ptr;
+        else x = tr->end_value._ptr;
+        _lv_style_set_ptr(style, tr->prop, x);
+    }
+    _lv_obj_refresh_style(tr->obj, tr->part, tr->prop);
+
+}
+
+static void trans_anim_start_cb(lv_anim_t * a)
+{
+    lv_style_trans_t * tr = a->var;
+
+    lv_style_property_t prop_tmp = tr->prop;
+
+    /*Start the animation from the current value*/
+    if((prop_tmp & 0xF) < LV_STYLE_ID_COLOR) { /*Int*/
+        tr->start_value._int = _lv_obj_get_style_int(tr->obj, tr->part, prop_tmp);
+    }
+    else if((prop_tmp & 0xF) < LV_STYLE_ID_OPA) { /*Color*/
+        tr->start_value._color = _lv_obj_get_style_color(tr->obj, tr->part, prop_tmp);
+    }
+    else if((prop_tmp & 0xF) < LV_STYLE_ID_PTR) { /*Opa*/
+        tr->start_value._opa = _lv_obj_get_style_opa(tr->obj, tr->part, prop_tmp);
+    }
+    else {      /*Ptr*/
+        tr->start_value._ptr = _lv_obj_get_style_ptr(tr->obj, tr->part, prop_tmp);
+    }
+
+    /*Init prop to an invalid values to be sure `trans_del` won't delete this added `tr`*/
+    tr->prop = 0;
+    /*Delete the relate transition if any*/
+    trans_del(tr->obj, tr->part, prop_tmp, tr);
+
+    tr->prop = prop_tmp;
+
+}
+
+static void trans_anim_ready_cb(lv_anim_t * a)
+{
+    lv_style_trans_t * tr = a->var;
+
+    /* Remove the transitioned property from trans. style
+     * if there no more transitions for this property
+     * It allows changing it by normal styles*/
+    bool running = false;
+    lv_style_trans_t * tr_i;
+    _LV_LL_READ(LV_GC_ROOT(_lv_obj_style_trans_ll), tr_i) {
+        if(tr_i != tr && tr_i->obj == tr->obj && tr_i->part == tr->part && tr_i->prop == tr->prop) {
+            running = true;
+        }
+    }
+
+    if(!running) {
+        lv_style_list_t * list = _lv_obj_get_style_list(tr->obj, tr->part);
+        lv_style_t * style_trans = _lv_style_list_get_transition_style(list);
+        lv_style_remove_prop(style_trans, tr->prop);
+    }
+
+    _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr);
+    lv_mem_free(tr);
+}
+
+#endif
+
+static bool style_prop_is_cacheable(lv_style_property_t prop)
+{
+
+    switch(prop) {
+        case LV_STYLE_PROP_ALL:
+        case LV_STYLE_BG_GRAD_DIR:
+        case LV_STYLE_CLIP_CORNER:
+        case LV_STYLE_TEXT_LETTER_SPACE:
+        case LV_STYLE_TEXT_LINE_SPACE:
+        case LV_STYLE_TEXT_FONT:
+        case LV_STYLE_TRANSFORM_ANGLE:
+        case LV_STYLE_TRANSFORM_WIDTH:
+        case LV_STYLE_TRANSFORM_HEIGHT:
+        case LV_STYLE_TRANSFORM_ZOOM:
+        case LV_STYLE_BORDER_WIDTH:
+        case LV_STYLE_OUTLINE_WIDTH:
+        case LV_STYLE_RADIUS:
+        case LV_STYLE_SHADOW_WIDTH:
+        case LV_STYLE_OPA_SCALE:
+        case LV_STYLE_BG_OPA:
+        case LV_STYLE_BORDER_SIDE:
+        case LV_STYLE_BORDER_POST:
+        case LV_STYLE_IMAGE_RECOLOR_OPA:
+        case LV_STYLE_VALUE_STR:
+        case LV_STYLE_PATTERN_IMAGE:
+        case LV_STYLE_PAD_TOP:
+        case LV_STYLE_PAD_BOTTOM:
+        case LV_STYLE_PAD_LEFT:
+        case LV_STYLE_PAD_RIGHT:
+        case LV_STYLE_MARGIN_TOP:
+        case LV_STYLE_MARGIN_BOTTOM:
+        case LV_STYLE_MARGIN_LEFT:
+        case LV_STYLE_MARGIN_RIGHT:
+        case LV_STYLE_BG_BLEND_MODE:
+        case LV_STYLE_BORDER_BLEND_MODE:
+        case LV_STYLE_IMAGE_BLEND_MODE:
+        case LV_STYLE_LINE_BLEND_MODE:
+        case LV_STYLE_OUTLINE_BLEND_MODE:
+        case LV_STYLE_PATTERN_BLEND_MODE:
+        case LV_STYLE_SHADOW_BLEND_MODE:
+        case LV_STYLE_TEXT_BLEND_MODE:
+        case LV_STYLE_VALUE_BLEND_MODE:
+            return true;
+            break;
+        default:
+            return false;
+    }
+}
+
+/**
+ * Update the cache of style list
+ * @param obj pointer to an obejct
+ * @param part the part of the object
+ * @param prop the property which triggered the update
+ */
+static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
+{
+    if(style_prop_is_cacheable(prop) == false) return;
+
+    lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+
+    bool ignore_cache_ori = list->ignore_cache;
+    list->ignore_cache = 1;
+
+#if LV_USE_OPA_SCALE
+    list->opa_scale_cover    = lv_obj_get_style_opa_scale(obj, part) == LV_OPA_COVER ? 1 : 0;
+#else
+    list->opa_scale_cover    = 1;
+#endif
+    list->text_decor_none    = lv_obj_get_style_text_decor(obj, part) == LV_TEXT_DECOR_NONE ? 1 : 0;
+    list->text_font_normal    = lv_obj_get_style_text_font(obj, part) == LV_THEME_DEFAULT_FONT_NORMAL ? 1 : 0;
+
+    list->text_space_zero = 1;
+    if(lv_obj_get_style_text_letter_space(obj, part) != 0 ||
+       lv_obj_get_style_text_line_space(obj, part) != 0) {
+        list->text_space_zero = 0;
+    }
+
+
+    lv_opa_t bg_opa = lv_obj_get_style_bg_opa(obj, part);
+    list->bg_opa_transp    = bg_opa == LV_OPA_TRANSP ? 1 : 0;
+    list->bg_opa_cover     = bg_opa == LV_OPA_COVER ? 1 : 0;
+
+    list->bg_grad_dir_none  = lv_obj_get_style_bg_grad_dir(obj, part) == LV_GRAD_DIR_NONE ? 1 : 0;
+    list->border_width_zero = lv_obj_get_style_border_width(obj, part) == 0 ? 1 : 0;
+    list->border_side_full = lv_obj_get_style_border_side(obj, part) == LV_BORDER_SIDE_FULL ? 1 : 0;
+    list->border_post_off = lv_obj_get_style_border_post(obj, part) == 0 ? 1 : 0;
+    list->clip_corner_off   = lv_obj_get_style_clip_corner(obj, part) == false ? 1 : 0;
+    list->img_recolor_opa_transp    = lv_obj_get_style_image_recolor_opa(obj, part) == LV_OPA_TRANSP ? 1 : 0;
+    list->outline_width_zero    = lv_obj_get_style_outline_width(obj, part) == 0 ? 1 : 0;
+    list->pattern_img_null    = lv_obj_get_style_pattern_image(obj, part) == NULL ? 1 : 0;
+    list->radius_zero    = lv_obj_get_style_radius(obj, part) == 0 ? 1 : 0;
+    list->shadow_width_zero    = lv_obj_get_style_shadow_width(obj, part) == 0 ? 1 : 0;
+    list->value_txt_str    = lv_obj_get_style_value_str(obj, part) == NULL ? 1 : 0;
+
+
+    list->transform_all_zero  = 1;
+    if(lv_obj_get_style_transform_angle(obj, part) != 0 ||
+       lv_obj_get_style_transform_width(obj, part) != 0 ||
+       lv_obj_get_style_transform_height(obj, part) != 0 ||
+       lv_obj_get_style_transform_zoom(obj, part) != LV_IMG_ZOOM_NONE) {
+        list->transform_all_zero  = 0;
+    }
+
+    list->pad_all_zero  = 1;
+    if(lv_obj_get_style_pad_top(obj, part) != 0 ||
+       lv_obj_get_style_pad_bottom(obj, part) != 0 ||
+       lv_obj_get_style_pad_left(obj, part) != 0 ||
+       lv_obj_get_style_pad_right(obj, part) != 0) {
+        list->pad_all_zero  = 0;
+    }
+
+    list->margin_all_zero  = 1;
+    if(lv_obj_get_style_margin_top(obj, part) != 0 ||
+       lv_obj_get_style_margin_bottom(obj, part) != 0 ||
+       lv_obj_get_style_margin_left(obj, part) != 0 ||
+       lv_obj_get_style_margin_right(obj, part) != 0) {
+        list->margin_all_zero  = 0;
+    }
+
+    list->blend_mode_all_normal = 1;
+#if LV_USE_BLEND_MODES
+    if(lv_obj_get_style_bg_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_border_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_pattern_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_outline_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_value_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_text_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_line_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_image_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL ||
+       lv_obj_get_style_shadow_blend_mode(obj, part) != LV_BLEND_MODE_NORMAL) {
+        list->blend_mode_all_normal = 0;
+    }
+#endif
+    list->ignore_cache = ignore_cache_ori;
+    list->valid_cache = 1;
+}
+
+/**
+ * Update the cache of style list
+ * @param obj pointer to an object
+ * @param part the part of the object
+ */
+static void update_style_cache_children(lv_obj_t * obj)
+{
+    uint8_t part;
+    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) break;
+
+        bool ignore_cache_ori = list->ignore_cache;
+        list->ignore_cache = 1;
+
+        list->opa_scale_cover    = lv_obj_get_style_opa_scale(obj, part) == LV_OPA_COVER ? 1 : 0;
+        list->text_decor_none    = lv_obj_get_style_text_decor(obj, part) == LV_TEXT_DECOR_NONE ? 1 : 0;
+        list->text_font_normal    = lv_obj_get_style_text_font(obj, part) == lv_theme_get_font_normal() ? 1 : 0;
+        list->img_recolor_opa_transp    = lv_obj_get_style_image_recolor_opa(obj, part) == LV_OPA_TRANSP ? 1 : 0;
+
+        list->text_space_zero = 1;
+        if(lv_obj_get_style_text_letter_space(obj, part) != 0 ||
+           lv_obj_get_style_text_line_space(obj, part) != 0) {
+            list->text_space_zero = 0;
+        }
+
+        list->ignore_cache = ignore_cache_ori;
+    }
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child) {
+        update_style_cache_children(child);
+        child = lv_obj_get_child(obj, child);
+    }
+
+}
+
+/**
+ * Mark the object and all of it's children's style lists as invalid.
+ * The cache will be updated when a cached property asked nest time
+ * @param obj pointer to an object
+ */
+static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    if(style_prop_is_cacheable(prop) == false) return;
+
+    if(part != LV_OBJ_PART_ALL) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) return;
+        list->valid_cache = 0;
+    }
+    else {
+
+        for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
+            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+            if(list == NULL) break;
+            list->valid_cache = 0;
+        }
+        for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
+            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+            if(list == NULL) break;
+            list->valid_cache = 0;
+        }
+    }
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child) {
+        update_style_cache_children(child);
+        child = lv_obj_get_child(obj, child);
+    }
+}
+
+static void fade_anim_cb(lv_obj_t * obj, lv_anim_value_t v)
+{
+    lv_obj_set_style_local_opa_scale(obj, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, v);
+}
+
+static void fade_in_anim_ready(lv_anim_t * a)
+{
+    lv_style_remove_prop(_lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+}
diff --git a/src/lv_core/lv_obj_style_dec.h b/src/lv_core/lv_obj_style.h
similarity index 58%
rename from src/lv_core/lv_obj_style_dec.h
rename to src/lv_core/lv_obj_style.h
index 8876412c3..fddf35f93 100644
--- a/src/lv_core/lv_obj_style_dec.h
+++ b/src/lv_core/lv_obj_style.h
@@ -1,20 +1,305 @@
-
 /**
- * @file lv_obj_style_dec.h
+ * @file lv_obj_style.h
  *
  */
 
-#ifndef LV_OBJ_STYLE_DEC_H
-#define LV_OBJ_STYLE_DEC_H
+#ifndef LV_OBJ_STYLE_H
+#define LV_OB_STYLE_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdint.h>
+#include <stdbool.h>
+#include "lv_style.h"
+
 /*********************
  *      DEFINES
  *********************/
 
+/**********************
+ *      TYPEDEFS
+ **********************/
+/* Can't include lv_obj.h because it includes this header file */
+struct _lv_obj_t;
+typedef struct _lv_obj_t lv_obj_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+
+/**
+ * Initialize the object related style manager module.
+ * Called by LVGL in `lv_init()`
+ */
+void _lv_obj_style_init(void);
+
+/**
+ * Add a new style to the style list of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param style pointer to a style to add (Only its pointer will be saved)
+ */
+void lv_obj_add_style(lv_obj_t * obj, uint8_t part, lv_style_t * style);
+
+/**
+ * Remove a style from the style list of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *              E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param style pointer to a style to remove
+ */
+void lv_obj_remove_style(lv_obj_t * obj, uint8_t part, lv_style_t * style);
+
+/**
+ * Reset a style to the default (empty) state.
+ * Release all used memories and cancel pending related transitions.
+ * Also notifies the object about the style change.
+ * @param obj pointer to an object
+ * @param part the part of the object which style list should be reseted.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ */
+void lv_obj_reset_style_list(lv_obj_t * obj, uint8_t part);
+
+/**
+ * Notify all object if a style is modified
+ * @param style pointer to a style. Only the objects with this style will be notified
+ *               (NULL to notify all objects)
+ */
+void lv_obj_report_style_change(lv_style_t * style);
+
+/**
+ * Remove a local style property from a part of an object with a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be removed.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @return true: the property was found and removed; false: the property was not found
+ */
+bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+
+#if LV_USE_ANIMATION
+
+/**
+ * Fade in (from transparent to fully cover) an object and all its children using an `opa_scale` animation.
+ * @param obj the object to fade in
+ * @param time duration of the animation [ms]
+ * @param delay wait before the animation starts [ms]
+ */
+void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay);
+
+/**
+ * Fade out (from fully cover to transparent) an object and all its children using an `opa_scale` animation.
+ * @param obj the object to fade in
+ * @param time duration of the animation [ms]
+ * @param delay wait before the animation starts [ms]
+ */
+void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
+
+#endif
+
+/**
+ * Get the style list of part of an object
+ * @param obj pointer to an object
+ * @param part the part of the object.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @return pointer to the style list
+ */
+lv_style_list_t * _lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part);
+
+/**
+ * Enable/disable the use of style cache for an object
+ * @param obj pointer to an object
+ * @param dis true: disable; false: enable (re-enable)
+ */
+void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_WIDTH`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_COLOR`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_color()`
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_BORDER_OPA`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+/**
+ * Get a style property of a part of an object in the object's current state.
+ * If there is a running transitions it is taken into account
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be get.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop the property to get. E.g. `LV_STYLE_TEXT_FONT`.
+ *  The state of the object will be added internally
+ * @return the value of the property of the given part in the current state.
+ * If the property is not found a default value will be returned.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+/**
+ * Get the local style of a part of an object.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @return pointer to the local style if exists else `NULL`.
+ */
+lv_style_t * _lv_obj_get_local_style(lv_obj_t * obj, uint8_t part);
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *              E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+void _lv_obj_set_style_local_int(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_style_int_t value);
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+void _lv_obj_set_style_local_color(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_color_t color);
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+void _lv_obj_set_style_local_opa(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, lv_opa_t opa);
+
+/**
+ * Set a local style property of a part of an object in a given state.
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be set.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ * @param prop a style property ORed with a state.
+ *             E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_obj_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t part, lv_style_property_t prop, const void * value);
+
+/**
+ * Reset a style to the default (empty) state.
+ * Release all used memories and cancel pending related transitions.
+ * Typically used in `LV_SIGNAL_CLEAN_UP.
+ * @param obj pointer to an object
+ * @param part the part of the object which style list should be reseted.
+ *             E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
+ */
+void _lv_obj_reset_style_list_no_refr(lv_obj_t * obj, uint8_t part);
+
+/**
+ * Notify an object and its children about its style is modified
+ * @param obj pointer to an object
+ * @param part the part of the object which style property should be refreshed.
+ * @param prop `LV_STYLE_PROP_ALL` or an `LV_STYLE_...` property. It is used to optimize what needs to be refreshed.
+ */
+void _lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+
+/**
+ * Remove all transitions from an object
+ * @param obj pointer to an object
+ */
+void _lv_obj_remove_style_trans(lv_obj_t * obj);
+
+#if LV_USE_ANIMATION
+
+/**
+ * Allocate and initialize a transition for a property of an object if the properties value is different in the new state.
+ * It allocates `lv_style_trans_t` in `_lv_obj_style_trans_ll` and set only `start/end_values`. No animation will be created here.
+ * @param obj and object to add the transition
+ * @param prop the property to apply the transaction
+ * @param part the part of the object to apply the transaction
+ * @param prev_state the previous state of the objects
+ * @param new_state the new state of the object
+ * @param time duration of transition in [ms]
+ * @param delay delay before starting the transition in [ms]
+ * @param path the path of the transition
+ * @return pointer to the allocated `the transaction` variable or `NULL` if no transition created
+ */
+void _lv_obj_create_style_transition(lv_obj_t * obj, lv_style_property_t prop, uint8_t part, lv_state_t prev_state,
+                                       lv_state_t new_state, uint32_t time, uint32_t delay, lv_anim_path_t * path);
+#endif
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+
 /**
  * Macro to declare the most important style set/get API functions.
  *
@@ -309,4 +594,4 @@ static inline void lv_style_set_margin_ver(lv_style_t * style, lv_state_t state,
 } /* extern "C" */
 #endif
 
-#endif /*LV_OBJ_H*/
+#endif /*LV_TEMPL_H*/
diff --git a/src/lv_font/lv_font.h b/src/lv_font/lv_font.h
index b3ecb881c..644a55e42 100644
--- a/src/lv_font/lv_font.h
+++ b/src/lv_font/lv_font.h
@@ -73,7 +73,7 @@ typedef struct _lv_font_struct {
     uint8_t subpx  : 2;             /**< An element of `lv_font_subpx_t`*/
 
     int8_t underline_position;      /**< Distance between the top of the underline and base line (< 0 means below the base line)*/
-    int8_t  underline_thickness;     /**< Thickness of the underline*/
+    int8_t underline_thickness;     /**< Thickness of the underline*/
 
     void * dsc;                     /**< Store implementation specific or run_time data or caching here*/
 #if LV_USE_USER_DATA
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index a13527f38..e5db6d723 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -206,269 +206,269 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
             break;
         case LV_THEME_OBJ:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTN_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BG);
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BTN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTNMATRIX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTNMATRIX_PART_BTN);
             break;
 #endif
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BG);
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BTN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_KEYBOARD_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_KEYBOARD_PART_BTN);
             break;
 #endif
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            lv_obj_clean_style_list(obj, LV_BAR_PART_BG);
-            lv_obj_clean_style_list(obj, LV_BAR_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BAR_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BAR_PART_INDIC);
             break;
 #endif
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_BG);
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_INDIC);
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_KNOB);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_KNOB);
             break;
 #endif
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            lv_obj_clean_style_list(obj, LV_CANVAS_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            lv_obj_clean_style_list(obj, LV_ARC_PART_BG);
-            lv_obj_clean_style_list(obj, LV_ARC_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_ARC_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_ARC_PART_INDIC);
             break;
 #endif
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_BG);
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SPINNER_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SPINNER_PART_INDIC);
             break;
 #endif
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_BG);
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_INDIC);
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_KNOB);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_KNOB);
             break;
 #endif
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BG);
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BULLET);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHECKBOX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHECKBOX_PART_BULLET);
             break;
 #endif
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_MSGBOX_PART_BG);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN_BG);
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_MSGBOX_PART_BTN_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_MSGBOX_PART_BTN);
             break;
 
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            lv_obj_clean_style_list(obj, LV_LED_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LED_PART_MAIN);
             break;
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_PAGE_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_PAGE_PART_SCROLLABLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_PAGE_PART_SCROLLBAR);
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG);
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BG);
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_INDIC);
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABVIEW_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABVIEW_PART_TAB_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABVIEW_PART_INDIC);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABVIEW_PART_TAB_BTN);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_PAGE_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_PAGE_PART_SCROLLABLE);
             break;
 #endif
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_BG);
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TILEVIEW_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TILEVIEW_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             break;
 #endif
 
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_BG);
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_SELECTED);
+            _lv_obj_reset_style_list_no_refr(obj, LV_ROLLER_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_ROLLER_PART_SELECTED);
             break;
 #endif
 
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            lv_obj_clean_style_list(obj, LV_OBJMASK_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            lv_obj_clean_style_list(obj, LV_LIST_PART_BG);
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLABLE);
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LIST_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LIST_PART_SCROLLABLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LIST_PART_SCROLLBAR);
             break;
 
         case LV_THEME_LIST_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTN_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_MAIN);
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_LIST);
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SELECTED);
+            _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_LIST);
+            _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_SELECTED);
             break;
 #endif
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            lv_obj_clean_style_list(obj, LV_CHART_PART_BG);
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES_BG);
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHART_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHART_PART_SERIES_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHART_PART_SERIES);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_BG);
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL1);
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL2);
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL3);
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL4);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABLE_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABLE_PART_CELL1);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABLE_PART_CELL2);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABLE_PART_CELL3);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TABLE_PART_CELL4);
             break;
 #endif
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            lv_obj_clean_style_list(obj, LV_WIN_PART_BG);
-            lv_obj_clean_style_list(obj, LV_WIN_PART_SCROLLBAR);
-            lv_obj_clean_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
-            lv_obj_clean_style_list(obj, LV_WIN_PART_HEADER);
+            _lv_obj_reset_style_list_no_refr(obj, LV_WIN_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_WIN_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_WIN_PART_HEADER);
             break;
 
         case LV_THEME_WIN_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTN_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_BG);
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_CURSOR);
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_PLACEHOLDER);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_CURSOR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_SCROLLBAR);
             break;
 #endif
 
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_BG);
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_CURSOR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SPINBOX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SPINBOX_PART_CURSOR);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTN_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_BG);
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DATE);
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_HEADER);
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CALENDAR_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CALENDAR_PART_DATE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CALENDAR_PART_HEADER);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CALENDAR_PART_DAY_NAMES);
             break;
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_MAIN);
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_KNOB);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CPICKER_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CPICKER_PART_KNOB);
             break;
 #endif
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            lv_obj_clean_style_list(obj, LV_LINEMETER_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_LINEMETER_PART_MAIN);
             break;
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAIN);
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAJOR);
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_NEEDLE);
+            _lv_obj_reset_style_list_no_refr(obj, LV_GAUGE_PART_MAIN);
+            _lv_obj_reset_style_list_no_refr(obj, LV_GAUGE_PART_MAJOR);
+            _lv_obj_reset_style_list_no_refr(obj, LV_GAUGE_PART_NEEDLE);
             break;
 #endif
         default:
diff --git a/src/lv_themes/lv_theme_empty.c b/src/lv_themes/lv_theme_empty.c
index 6900ef23c..027528d7c 100644
--- a/src/lv_themes/lv_theme_empty.c
+++ b/src/lv_themes/lv_theme_empty.c
@@ -99,7 +99,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 {
     LV_UNUSED(th);
     if(name == LV_THEME_SCR) {
-        lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+        _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
         lv_obj_add_style(obj, LV_OBJ_PART_MAIN, &styles->opa_cover);
     }
 }
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 5f7e5f43d..5116e85e8 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -961,7 +961,7 @@ lv_theme_t * lv_theme_material_init(lv_color_t color_primary, lv_color_t color_s
 
     inited = true;
 
-    lv_obj_report_style_mod(NULL);
+    lv_obj_report_style_change(NULL);
 
     return &theme;
 }
@@ -978,34 +978,34 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->scr);
             break;
         case LV_THEME_OBJ:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->btn);
             break;
 #endif
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             break;
@@ -1013,11 +1013,11 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
             _lv_style_list_add_style(list, &styles->kb_bg);
 
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             break;
@@ -1025,23 +1025,23 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
             break;
 #endif
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->sw_knob);
             break;
 #endif
@@ -1073,14 +1073,14 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
 
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             _lv_style_list_add_style(list, &styles->arc_knob);
@@ -1089,34 +1089,34 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
             break;
 #endif
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
             _lv_style_list_add_style(list, &styles->slider_bg);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->slider_knob);
             break;
 #endif
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->cb_bg);
 
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->cb_bullet);
             break;
@@ -1124,60 +1124,60 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->mbox_bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->btn);
             break;
 
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->led);
             break;
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
 #if LV_USE_ANIMATION
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_EDGE_FLASH);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->edge_flash);
 #endif
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->tabview_btns_bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
             _lv_style_list_add_style(list, &styles->tabview_indic);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->tabview_btns);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->tabview_page_scrl);
 
             break;
@@ -1185,14 +1185,14 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
 #if LV_USE_ANIMATION
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->edge_flash);
 #endif
             break;
@@ -1201,125 +1201,125 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->roller_bg);
 
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->roller_sel);
             break;
 #endif
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->list_bg);
 
 
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 
         case LV_THEME_LIST_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->list_btn);
             break;
 #endif
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->ddlist_page);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->ddlist_sel);
             break;
 #endif
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->chart_bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
             _lv_style_list_add_style(list, &styles->chart_series_bg);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->chart_series);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->table_cell);
             break;
 #endif
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->tabview_page_scrl);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->tabview_btns_bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->tabview_btns);
             break;
 #endif
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_style_list_add_style(list, &styles->ta_placeholder);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 
@@ -1328,16 +1328,16 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->spinbox_cursor);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             break;
@@ -1345,46 +1345,46 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->calendar_date_nums);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->calendar_header);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->calendar_daynames);
             break;
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->cpicker_bg);
 
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->cpicker_indic);
             break;
 #endif
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->lmeter);
             break;
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gauge_main);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->gauge_strong);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->gauge_needle);
             break;
 #endif
@@ -1392,7 +1392,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
     }
 
-    lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
 }
 
 /**********************
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index e9f0f9015..8a251cc12 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -577,23 +577,23 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->scr);
             break;
         case LV_THEME_OBJ:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->txt_underline);
@@ -602,10 +602,10 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->txt_underline);
@@ -614,11 +614,11 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -626,12 +626,12 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->round);
@@ -640,16 +640,16 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
@@ -658,51 +658,51 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            list = lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
             break;
 #endif
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->tick_line);
@@ -711,15 +711,15 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             _lv_style_list_add_style(list, &styles->pad_small);
@@ -729,10 +729,10 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->pad_small);
@@ -741,15 +741,15 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->txt_underline);
@@ -758,40 +758,40 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             break;
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->tab_bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_normal);
 
             break;
@@ -799,13 +799,13 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
@@ -813,11 +813,11 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->big_line_space);
 
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->no_radius);
@@ -827,23 +827,23 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->clip_corner);
 
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 
         case LV_THEME_LIST_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->list_btn);
@@ -854,18 +854,18 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->big_line_space);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->no_radius);
@@ -874,35 +874,35 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->border_none);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->chart_series);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
             break;
@@ -910,21 +910,21 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -932,13 +932,13 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 #endif
@@ -946,10 +946,10 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->pad_none);
@@ -958,7 +958,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->txt_underline);
@@ -967,31 +967,31 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->pad_small);
             _lv_style_list_add_style(list, &styles->border_none);
             _lv_style_list_add_style(list, &styles->calendar_date);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->pad_normal);
             _lv_style_list_add_style(list, &styles->border_none);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
             break;
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             break;
@@ -999,7 +999,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             _lv_style_list_add_style(list, &styles->linemeter);
@@ -1007,14 +1007,14 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->gauge_major);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->gauge_needle);
             break;
 #endif
@@ -1023,7 +1023,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
     }
 
 
-    lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
 
 
 }
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index 722e72e07..6777d2846 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -420,24 +420,24 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             break;
         case LV_THEME_OBJ:
-            list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -445,10 +445,10 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -456,10 +456,10 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -467,11 +467,11 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
 
-            list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             break;
@@ -479,16 +479,16 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             _lv_style_list_add_style(list, &styles->round);
@@ -497,42 +497,42 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            list = lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             _lv_style_list_add_style(list, &styles->tick_line);
@@ -541,11 +541,11 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             _lv_style_list_add_style(list, &styles->tick_line);
@@ -554,14 +554,14 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             break;
@@ -569,9 +569,9 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
 
-            list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -579,15 +579,15 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
+            list = _lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -595,7 +595,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             _lv_style_list_add_style(list, &styles->round);
@@ -603,44 +603,44 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gray);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
+            list = _lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gray);
 
-            list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
             break;
@@ -648,13 +648,13 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
+            list = _lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
@@ -662,10 +662,10 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             break;
@@ -674,23 +674,23 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLABLE);
 
-            list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_LIST_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -698,17 +698,17 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
+            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
             break;
@@ -716,53 +716,53 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
+            list = _lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -770,17 +770,17 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_style_list_add_style(list, &styles->gray);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
 
-            list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
@@ -788,15 +788,15 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
+            list = _lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -804,28 +804,28 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->tight);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
+            list = _lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             break;
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
+            list = _lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             break;
@@ -833,21 +833,21 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             break;
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
+            list = _lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
@@ -855,7 +855,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             break;
     }
 
-    lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
 }
 
 /**********************
diff --git a/src/lv_widgets/lv_label.c b/src/lv_widgets/lv_label.c
index f06595269..cfb74e16e 100644
--- a/src/lv_widgets/lv_label.c
+++ b/src/lv_widgets/lv_label.c
@@ -161,7 +161,7 @@ lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->dot_end       = copy_ext->dot_end;
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(new_label, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(new_label, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("label created");

From 8b969fab61f0614d303cf95d723d8f21e1119002 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 8 Sep 2020 09:56:56 +0200
Subject: [PATCH 27/84] imporve grid performance

---
 src/lv_core/lv_core.mk        |   5 +
 src/lv_core/lv_grid.c         | 338 +++++++++-------
 src/lv_core/lv_grid.h         |   6 +-
 src/lv_core/lv_indev.c        |   4 +-
 src/lv_core/lv_indev_scroll.c |   2 +-
 src/lv_core/lv_obj.c          | 724 +++++-----------------------------
 src/lv_core/lv_obj.h          | 129 ++----
 src/lv_core/lv_obj_pos.c      |  76 ++--
 src/lv_core/lv_obj_pos.h      | 168 ++++----
 src/lv_core/lv_obj_scroll.c   |   1 +
 src/lv_core/lv_obj_scroll.h   |  23 +-
 src/lv_core/lv_obj_style.c    |  51 ++-
 src/lv_core/lv_style.c        |   4 +-
 src/lv_core/lv_style.h        |  15 +-
 src/lv_widgets/lv_label.c     |   2 +-
 15 files changed, 499 insertions(+), 1049 deletions(-)

diff --git a/src/lv_core/lv_core.mk b/src/lv_core/lv_core.mk
index 9f15199bd..fab150b13 100644
--- a/src/lv_core/lv_core.mk
+++ b/src/lv_core/lv_core.mk
@@ -1,8 +1,13 @@
 CSRCS += lv_grid.c
 CSRCS += lv_group.c
 CSRCS += lv_indev.c
+CSRCS += lv_indev_scroll.c
 CSRCS += lv_disp.c
 CSRCS += lv_obj.c
+CSRCS += lv_obj_pos.c
+CSRCS += lv_obj_style.c
+CSRCS += lv_obj_draw.c
+CSRCS += lv_obj_scroll.c
 CSRCS += lv_refr.c
 CSRCS += lv_style.c
 
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 3c8fcd820..c68a649a3 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -17,6 +17,11 @@
 /**********************
  *      TYPEDEFS
  **********************/
+typedef struct {
+    uint32_t col;
+    uint32_t row;
+    lv_point_t grid_abs;
+}item_repos_hint_t;
 
 /**********************
  *  STATIC PROTOTYPES
@@ -25,6 +30,7 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint);
 
 /**********************
  *  STATIC VARIABLES
@@ -42,36 +48,47 @@ static bool row_dsc_buf_used;
  *   GLOBAL FUNCTIONS
  **********************/
 
-void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc)
+/**
+ * Calculate the grid cells coordinates
+ * @param obj an object that has a grid
+ * @param calc store the calculated cells sizes here
+ * @note `_lv_grid_calc_free(calc_out)` needs to be called when `calc_out` is not needed anymore
+ */
+void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc_out)
 {
     if(obj->grid == NULL) return;
-
-//    static uint32_t cnt = 0;
-//    cnt++;
-//    printf("calc: %d (size: %d)\n", cnt, obj->grid->col_dsc_len);
+//    printf("calc: %d, %d\n", obj->grid->col_dsc_len, obj->grid->row_dsc_len);
 
     if(obj->grid->col_dsc && obj->grid->row_dsc) {
-        calc_explicit_rows(obj, calc);
-        calc_explicit_cols(obj, calc);
+        calc_explicit_rows(obj, calc_out);
+        calc_explicit_cols(obj, calc_out);
     }
     else if(obj->grid->col_dsc && !obj->grid->row_dsc) {
-        calc_explicit_cols(obj, calc);
-        calc_implicit_rows(obj, calc);
+        calc_explicit_cols(obj, calc_out);
+        calc_implicit_rows(obj, calc_out);
     }
     else if(!obj->grid->col_dsc && obj->grid->row_dsc) {
-        calc_implicit_cols(obj, calc);
-        calc_explicit_rows(obj, calc);
+        calc_implicit_cols(obj, calc_out);
+        calc_explicit_rows(obj, calc_out);
     }
 
 }
 
-void grid_calc_free(_lv_grid_calc_t * calc)
+/**
+ * Free the a grid calculation's data
+ * @param calc pointer to the calculated gtrid cell coordinates
+ */
+void _lv_grid_calc_free(_lv_grid_calc_t * calc)
 {
     _lv_mem_buf_release(calc->col_dsc);
     _lv_mem_buf_release(calc->row_dsc);
 }
 
-
+/**
+ * Check if the object's grid columns has FR cells or not
+ * @param obj pointer to an object
+ * @return true: has FR; false: has no FR
+ */
 bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
 {
     if(obj->grid == NULL) return false;
@@ -85,6 +102,11 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
     return false;
 }
 
+/**
+ * Check if the object's grid rows has FR cells or not
+ * @param obj pointer to an object
+ * @return true: has FR; false: has no FR
+ */
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
 {
     if(obj->grid == NULL) return false;
@@ -98,164 +120,58 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
     return false;
 }
 
-
-
-static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, uint32_t * child_id_ext, lv_point_t * grid_abs)
-{
-    if(_lv_obj_is_grid_item(item) == false) return;
-
-    uint32_t col_pos;
-    uint32_t col_span;
-    uint32_t row_pos;
-    uint32_t row_span;
-
-    if(cont->grid->row_dsc && cont->grid->col_dsc) {
-        col_pos = _GRID_GET_CELL_POS(item->x_set);
-        col_span = _GRID_GET_CELL_SPAN(item->x_set);
-        row_pos = _GRID_GET_CELL_POS(item->y_set);
-        row_span = _GRID_GET_CELL_SPAN(item->y_set);
-    } else {
-        col_span = 1;
-        row_span = 1;
-
-        uint32_t child_id = 0;
-        if(child_id_ext) child_id = *child_id_ext;
-        else {
-            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
-
-            while(child) {
-                if(child == item) break;
-                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-                    child_id++;
-                }
-                child = lv_obj_get_child_back(cont, child);
-            }
-        }
-
-        if(cont->grid->row_dsc == NULL) {
-            col_pos = child_id % cont->grid->col_dsc_len;
-            row_pos = child_id / cont->grid->col_dsc_len;
-        } else {
-            col_pos = child_id / cont->grid->row_dsc_len;
-            row_pos = child_id % cont->grid->row_dsc_len;
-        }
-    }
-
-    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
-    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
-
-    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
-    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
-
-    lv_coord_t x;
-    lv_coord_t y;
-    lv_coord_t w = lv_obj_get_width(item);
-    lv_coord_t h = lv_obj_get_height(item);
-
-    switch(x_flag) {
-        case LV_GRID_START:
-            x = calc->col_dsc[col_pos];
-            break;
-        case LV_GRID_STRETCH:
-            x = calc->col_dsc[col_pos];
-            w = col_w;
-            item->w_set = LV_SIZE_STRETCH;
-            break;
-        case LV_GRID_CENTER:
-            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
-            break;
-        case LV_GRID_END:
-            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
-            break;
-    }
-
-    switch(y_flag) {
-        case LV_GRID_START:
-            y = calc->row_dsc[row_pos];
-            break;
-        case LV_GRID_STRETCH:
-            y = calc->row_dsc[row_pos];
-            item->h_set = LV_SIZE_STRETCH;
-            h = row_h;
-            break;
-        case LV_GRID_CENTER:
-            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
-            break;
-        case LV_GRID_END:
-            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
-            break;
-    }
-
-    /*Set a new size if required*/
-    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
-        lv_area_t old_coords;
-        lv_area_copy(&old_coords, &item->coords);
-        lv_obj_invalidate(item);
-        lv_area_set_width(&item->coords, w);
-        lv_area_set_height(&item->coords, h);
-        lv_obj_invalidate(item);
-        item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
-
-        /* If a children is a grid container and has an FR field it also needs to be updated
-         * because the FR cell size will change with child size change. */
-        lv_obj_t * child = lv_obj_get_child(item, NULL);
-        while(child) {
-            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
-                lv_grid_full_refr(child);
-            }
-            child = lv_obj_get_child(item, child);
-        }
-    }
-    bool moved = true;
-    if(grid_abs) {
-        if(grid_abs->x + x == item->coords.x1 && grid_abs->y + y == item->coords.y1) moved = false;
-    }
-
-    if(moved) _lv_obj_move_to(item, x, y, false);
-}
-
-void lv_grid_full_refr(lv_obj_t * cont)
+/**
+ * Refresh the all grid item on a container
+ * @param cont pointer to a grid container object
+ */
+void _lv_grid_full_refresh(lv_obj_t * cont)
 {
     /*Calculate the grid*/
     if(cont->grid == NULL) return;
     _lv_grid_calc_t calc;
-    grid_calc(cont, &calc);
+    _lv_grid_calc(cont, &calc);
+
+
+    item_repos_hint_t hint;
+    _lv_memset_00(&hint, sizeof(hint));
 
     /* Calculate the grids absolute x and y coordinates.
      * It will be used as helper during item repositioning to avoid calculating this value for every children*/
-    lv_point_t grid_abs;
     lv_coord_t pad_left = lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN);
     lv_coord_t pad_top = lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN);
-    grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
-    grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
+    hint.grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
+    hint.grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
 
-    uint32_t child_id = 0;
     lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
     while(item) {
         if(_GRID_IS_CELL(item->x_set) && _GRID_IS_CELL(item->y_set)) {
-            _grid_item_repos(cont, item, &calc, &child_id, &grid_abs);
-            child_id++;
+            item_repos(cont, item, &calc, &hint);
         }
         item = lv_obj_get_child_back(cont, item);
     }
-    grid_calc_free(&calc);
+    _lv_grid_calc_free(&calc);
 
     if(cont->w_set == LV_SIZE_AUTO || cont->h_set == LV_SIZE_AUTO) {
         lv_obj_set_size(cont, cont->w_set, cont->h_set);
     }
 }
 
+/**
+ * Refresh the position of a grid item
+ * @param item pointer to a grid item
+ */
 void lv_grid_item_refr_pos(lv_obj_t * item)
 {
     /*Calculate the grid*/
     lv_obj_t * cont = lv_obj_get_parent(item);
+    if(cont == NULL) return;
     if(cont->grid == NULL) return;
     _lv_grid_calc_t calc;
-    grid_calc(cont, &calc);
+    _lv_grid_calc(cont, &calc);
 
-    _grid_item_repos(cont, item, &calc, NULL, NULL);
+    item_repos(cont, item, &calc, NULL);
 
-    grid_calc_free(&calc);
+    _lv_grid_calc_free(&calc);
 }
 
 /**********************
@@ -479,3 +395,143 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
     if(row_dsc_buf_used && row_dsc_buf_mine) row_dsc_buf_used = false;
     else _lv_mem_buf_release(rows_h);
 }
+
+
+/**
+ * Reposition a grid item in its cell
+ * @param cont a grid container object
+ * @param item a grid item to reposition
+ * @param calc the calculated grid of `cont`
+ * @param child_id_ext helper value if the ID of the child is know (order from the oldest) else -1
+ * @param grid_abs helper value, the absolute position of the grid, NULL if unknown
+ */
+static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint)
+{
+    if(_lv_obj_is_grid_item(item) == false) return;
+
+    uint32_t col_pos;
+    uint32_t col_span;
+    uint32_t row_pos;
+    uint32_t row_span;
+
+    if(cont->grid->row_dsc && cont->grid->col_dsc) {
+        col_pos = _GRID_GET_CELL_POS(item->x_set);
+        col_span = _GRID_GET_CELL_SPAN(item->x_set);
+        row_pos = _GRID_GET_CELL_POS(item->y_set);
+        row_span = _GRID_GET_CELL_SPAN(item->y_set);
+    } else {
+        col_span = 1;
+        row_span = 1;
+
+        if(hint) {
+            col_pos = hint->col;
+            row_pos = hint->row;
+
+            if(cont->grid->row_dsc == NULL) {
+                hint->col++;
+                if(hint->col >= cont->grid->col_dsc_len) {
+                    hint->col = 0;
+                    hint->row++;
+                }
+            } else {
+                if(hint->row >= cont->grid->row_dsc_len) {
+                    hint->row = 0;
+                    hint->col++;
+                }
+            }
+        }
+        /*No hint -> find the child ID and calculate its col and row position */
+        else {
+            uint32_t child_id = 0;
+            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
+
+            while(child) {
+                if(child == item) break;
+                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+                    child_id++;
+                }
+                child = lv_obj_get_child_back(cont, child);
+            }
+
+            if(cont->grid->row_dsc == NULL) {
+                col_pos = child_id % cont->grid->col_dsc_len;
+                row_pos = child_id / cont->grid->col_dsc_len;
+            } else {
+                col_pos = child_id / cont->grid->row_dsc_len;
+                row_pos = child_id % cont->grid->row_dsc_len;
+            }
+        }
+    }
+
+    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
+    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
+
+    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
+    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
+
+    lv_coord_t x;
+    lv_coord_t y;
+    lv_coord_t w = lv_obj_get_width(item);
+    lv_coord_t h = lv_obj_get_height(item);
+
+    switch(x_flag) {
+        case LV_GRID_START:
+            x = calc->col_dsc[col_pos];
+            break;
+        case LV_GRID_STRETCH:
+            x = calc->col_dsc[col_pos];
+            w = col_w;
+            item->w_set = LV_SIZE_STRETCH;
+            break;
+        case LV_GRID_CENTER:
+            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
+            break;
+        case LV_GRID_END:
+            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
+            break;
+    }
+
+    switch(y_flag) {
+        case LV_GRID_START:
+            y = calc->row_dsc[row_pos];
+            break;
+        case LV_GRID_STRETCH:
+            y = calc->row_dsc[row_pos];
+            item->h_set = LV_SIZE_STRETCH;
+            h = row_h;
+            break;
+        case LV_GRID_CENTER:
+            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
+            break;
+        case LV_GRID_END:
+            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
+            break;
+    }
+
+    /*Set a new size if required*/
+    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
+        lv_area_t old_coords;
+        lv_area_copy(&old_coords, &item->coords);
+        lv_obj_invalidate(item);
+        lv_area_set_width(&item->coords, w);
+        lv_area_set_height(&item->coords, h);
+        lv_obj_invalidate(item);
+        item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
+
+        /* If a children is a grid container and has an FR field it also needs to be updated
+         * because the FR cell size will change with child size change. */
+        lv_obj_t * child = lv_obj_get_child(item, NULL);
+        while(child) {
+            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
+                _lv_grid_full_refresh(child);
+            }
+            child = lv_obj_get_child(item, child);
+        }
+    }
+    bool moved = true;
+    if(hint) {
+        if(hint->grid_abs.x + x == item->coords.x1 && hint->grid_abs.y + y == item->coords.y1) moved = false;
+    }
+
+    if(moved) _lv_obj_move_to(item, x, y, false);
+}
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 846ca718a..9fef06cdf 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -113,15 +113,15 @@ void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv
 
 void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
 
-void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc);
+void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc);
 
-void grid_calc_free(_lv_grid_calc_t * calc);
+void _lv_grid_calc_free(_lv_grid_calc_t * calc);
 
 bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
 
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 
-void lv_grid_full_refr(lv_obj_t * cont);
+void _lv_grid_full_refresh(lv_obj_t * cont);
 
 void lv_grid_item_refr_pos(lv_obj_t * item);
 
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 50ad967df..565eb020f 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1053,7 +1053,7 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
     lv_obj_t * found_p = NULL;
 
     /*If the point is on this object check its children too*/
-    if(lv_obj_hittest(obj, point)) {
+    if(lv_obj_hit_test(obj, point)) {
         lv_obj_t * i;
 
         _LV_LL_READ(obj->child_ll, i) {
@@ -1088,7 +1088,7 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
 static void indev_click_focus(lv_indev_proc_t * proc)
 {
     /*Handle click focus*/
-    lv_obj_t * obj_to_focus = lv_obj_get_focused_obj(indev_obj_act);
+    lv_obj_t * obj_to_focus = _lv_obj_get_focused_obj(indev_obj_act);
     if(lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_PRESS_LOCK) == false &&
        proc->types.pointer.last_pressed != obj_to_focus) {
 #if LV_USE_GROUP
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index fa0fcfc89..d8f859203 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -1,5 +1,5 @@
 /**
- * @file lv_scroll.c
+ * @file lv_indev_scroll.c
  *
  */
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index caeecc90d..3ce1e7951 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -48,8 +48,7 @@
 #define LV_OBJX_NAME "lv_obj"
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
-#define SCROLLBAR_MIN_SIZE (LV_DPX(10))
-#define GRID_DEBUG  1 /*Draw rectangles on grid cells*/
+#define GRID_DEBUG  0 /*Draw rectangles on grid cells*/
 
 /**********************
  *      TYPEDEFS
@@ -70,8 +69,6 @@ static void lv_event_mark_deleted(lv_obj_t * obj);
 static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
 static void lv_obj_del_async_cb(void * obj);
 static void obj_del_core(lv_obj_t * obj);
-static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
-static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area);
 static void base_dir_refr_children(lv_obj_t * obj);
 
 /**********************
@@ -270,8 +267,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
     _lv_memset_00(&new_obj->ext_click_pad, sizeof(new_obj->ext_click_pad));
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    new_obj->ext_click_pad_hor = 0;
-    new_obj->ext_click_pad_ver = 0;
+    new_obj->ext_click_pad = 0;
 #endif
 
     /*Init. user date*/
@@ -286,7 +282,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 #endif
 
     /*Set attributes*/
-    new_obj->adv_hittest  = 0;
     new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
     new_obj->scroll_dir  = LV_DIR_ALL;
     new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
@@ -313,8 +308,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
         lv_area_copy(&new_obj->ext_click_pad, &copy->ext_click_pad);
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-        new_obj->ext_click_pad_hor = copy->ext_click_pad_hor;
-        new_obj->ext_click_pad_ver = copy->ext_click_pad_ver;
+        new_obj->ext_click_pad = copy->ext_click_pad;
 #endif
 
         /*Set user data*/
@@ -327,7 +321,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         new_obj->event_cb = copy->event_cb;
 
         /*Copy attributes*/
-        new_obj->adv_hittest  = copy->adv_hittest;
         new_obj->flags        = copy->flags;
         new_obj->scroll_mode  = copy->scroll_mode;
 
@@ -677,14 +670,13 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
     obj->ext_click_pad.y1 = top;
     obj->ext_click_pad.y2 = bottom;
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    obj->ext_click_pad_hor = LV_MATH_MAX(left, right);
-    obj->ext_click_pad_ver = LV_MATH_MAX(top, bottom);
+    obj->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
 #else
-    (void)obj;    /*Unused*/
-    (void)left;   /*Unused*/
-    (void)right;  /*Unused*/
-    (void)top;    /*Unused*/
-    (void)bottom; /*Unused*/
+    LV_UNUSED(obj);
+    LV_UNUSED(left);
+    LV_UNUSED(right);
+    LV_UNUSED(top);
+    LV_UNUSED(bottom);
 #endif
 }
 
@@ -696,19 +688,6 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
  * Attribute set
  *----------------*/
 
-/**
- * Set whether advanced hit-testing is enabled on an object
- * @param obj pointer to an object
- * @param en true: advanced hit-testing is enabled
- */
-void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->adv_hittest = en == false ? 0 : 1;
-}
-
-
 /**
  * Set the base direction of the object
  * @param obj pointer to an object
@@ -1050,19 +1029,6 @@ void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size)
     return (void *)obj->ext_attr;
 }
 
-/**
- * Send a 'LV_SIGNAL_REFR_EXT_SIZE' signal to the object to refresh the extended draw area.
- * he object needs to be invalidated by `lv_obj_invalidate(obj)` manually after this function.
- * @param obj pointer to an object
- */
-void lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    obj->ext_draw_pad = 0;
-    obj->signal_cb(obj, LV_SIGNAL_REFR_EXT_DRAW_PAD, NULL);
-
-}
 
 /*=======================
  * Getter functions
@@ -1201,93 +1167,90 @@ uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj)
  *--------------------*/
 
 /**
- * Get the left padding of extended clickable area
+ * Get the extended extended clickable area in a direction
  * @param obj pointer to an object
+ * @param dir in which direction get the extended area (`LV_DIR_LEFT/RIGHT/TOP`)
  * @return the extended left padding
  */
-lv_coord_t lv_obj_get_ext_click_pad_left(const lv_obj_t * obj)
+lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir)
 {
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    return obj->ext_click_pad_hor;
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    return obj->ext_click_pad.x1;
-#else
-    (void)obj;    /*Unused*/
+#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_OFF
+    LV_UNUSED(obj);
+    LV_UNUSED(dir);
     return 0;
+#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
+    LV_UNUSED(dir);
+    return obj->ext_click_pad;
+#else
+    switch(dir) {
+    case LV_DIR_LEFT:
+        return obj->ext_click_pad.x1;
+    case LV_DIR_RIGHT:
+        return obj->ext_click_pad.x2;
+    case LV_DIR_TOP:
+        return obj->ext_click_pad.y1;
+    case LV_DIR_BOTTOM:
+        return obj->ext_click_pad.y2;
+    default:
+        return 0;
+    }
 #endif
 }
 
-/**
- * Get the right padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended right padding
- */
-lv_coord_t lv_obj_get_ext_click_pad_right(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
+/**
+ * Check if a given screen-space point is on an object's coordinates.
+ * This method is intended to be used mainly by advanced hit testing algorithms to check
+ * whether the point is even within the object (as an optimization).
+ * @param obj object to check
+ * @param point screen-space point
+ */
+bool _lv_obj_is_click_point_on(lv_obj_t * obj, const lv_point_t * point)
+{
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    return obj->ext_click_pad_hor;
+    lv_area_t ext_area;
+    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad;
+    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad;
+    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad;
+    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad;
+
+    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    return obj->ext_click_pad.x2;
+    lv_area_t ext_area;
+    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
+    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
+    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
+    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
+
+    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
 #else
-    (void)obj; /*Unused*/
-    return 0;
+    if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
 #endif
+        return false;
+    }
+    return true;
 }
 
 /**
- * Get the top padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended top padding
+ * Hit-test an object given a particular point in screen space.
+ * @param obj object to hit-test
+ * @param point screen-space point
+ * @return true if the object is considered under the point
  */
-lv_coord_t lv_obj_get_ext_click_pad_top(const lv_obj_t * obj)
+bool lv_obj_hit_test(lv_obj_t * obj, lv_point_t * point)
 {
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    return obj->ext_click_pad_ver;
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    return obj->ext_click_pad.y1;
-#else
-    (void)obj; /*Unused*/
-    return 0;
-#endif
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_ADV_HITTEST)) {
+        lv_hit_test_info_t hit_info;
+        hit_info.point = point;
+        hit_info.result = true;
+        obj->signal_cb(obj, LV_SIGNAL_HIT_TEST, &hit_info);
+        return hit_info.result;
+    }
+    else {
+        return _lv_obj_is_click_point_on(obj, point);
+    }
 }
-
-/**
- * Get the bottom padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended bottom padding
- */
-lv_coord_t lv_obj_get_ext_click_pad_bottom(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    return obj->ext_click_pad_ver;
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    return obj->ext_click_pad.y2;
-#else
-    (void)obj; /*Unused*/
-    return 0;
-#endif
-}
-
-/**
- * Get the extended size attribute of an object
- * @param obj pointer to an object
- * @return the extended size attribute
- */
-lv_coord_t lv_obj_get_ext_draw_pad(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->ext_draw_pad;
-}
-
 /*-----------------
  * Appearance get
  *---------------*/
@@ -1304,19 +1267,6 @@ bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f)
     return obj->flags & f ? true : false;
 }
 
-/**
- * Get whether advanced hit-testing is enabled on an object
- * @param obj pointer to an object
- * @return true: advanced hit-testing is enabled
- */
-bool lv_obj_get_adv_hittest(const lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->adv_hittest == 0 ? false : true;
-}
-
-
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@@ -1525,7 +1475,7 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
  * @param obj the start object
  * @return the object to really focus
  */
-lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
+lv_obj_t * _lv_obj_get_focused_obj(const lv_obj_t * obj)
 {
     if(obj == NULL) return NULL;
     const lv_obj_t * focus_obj = obj;
@@ -1536,26 +1486,6 @@ lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
     return (lv_obj_t *)focus_obj;
 }
 
-
-/**
- * Hit-test an object given a particular point in screen space.
- * @param obj object to hit-test
- * @param point screen-space point
- * @return true if the object is considered under the point
- */
-bool lv_obj_hittest(lv_obj_t * obj, lv_point_t * point)
-{
-    if(obj->adv_hittest) {
-        lv_hit_test_info_t hit_info;
-        hit_info.point = point;
-        hit_info.result = true;
-        obj->signal_cb(obj, LV_SIGNAL_HIT_TEST, &hit_info);
-        return hit_info.result;
-    }
-    else
-        return lv_obj_is_point_on_coords(obj, point);
-}
-
 /**
  * Used in the signal callback to handle `LV_SIGNAL_GET_TYPE` signal
  * @param obj pointer to an object
@@ -1563,7 +1493,7 @@ bool lv_obj_hittest(lv_obj_t * obj, lv_point_t * point)
  * @param name name of the object. E.g. "lv_btn". (Only the pointer is saved)
  * @return LV_RES_OK
  */
-lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name)
+lv_res_t _lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name)
 {
     uint8_t i;
     for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
@@ -1574,314 +1504,6 @@ lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name)
     return LV_RES_OK;
 }
 
-/**
- * Initialize a rectangle descriptor from an object's styles
- * @param obj pointer to an object
- * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_STYLE_REL` or `LV_PAGE_STYLE_SCRL`
- * @param draw_dsc the descriptor the initialize
- * @note Only the relevant fields will be set.
- * E.g. if `border width == 0` the other border properties won't be evaluated.
- */
-void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t * draw_dsc)
-{
-    draw_dsc->radius = lv_obj_get_style_radius(obj, part);
-
-#if LV_USE_OPA_SCALE
-    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
-    if(opa_scale <= LV_OPA_MIN) {
-        draw_dsc->bg_opa = LV_OPA_TRANSP;
-        draw_dsc->border_opa = LV_OPA_TRANSP;
-        draw_dsc->shadow_opa = LV_OPA_TRANSP;
-        draw_dsc->pattern_opa = LV_OPA_TRANSP;
-        draw_dsc->value_opa = LV_OPA_TRANSP;
-        return;
-    }
-#endif
-
-    if(draw_dsc->bg_opa != LV_OPA_TRANSP) {
-        draw_dsc->bg_opa = lv_obj_get_style_bg_opa(obj, part);
-        if(draw_dsc->bg_opa > LV_OPA_MIN) {
-            draw_dsc->bg_color = lv_obj_get_style_bg_color(obj, part);
-            draw_dsc->bg_grad_dir =  lv_obj_get_style_bg_grad_dir(obj, part);
-            if(draw_dsc->bg_grad_dir != LV_GRAD_DIR_NONE) {
-                draw_dsc->bg_grad_color = lv_obj_get_style_bg_grad_color(obj, part);
-                draw_dsc->bg_main_color_stop =  lv_obj_get_style_bg_main_stop(obj, part);
-                draw_dsc->bg_grad_color_stop =  lv_obj_get_style_bg_grad_stop(obj, part);
-            }
-
-#if LV_USE_BLEND_MODES
-            draw_dsc->bg_blend_mode = lv_obj_get_style_bg_blend_mode(obj, part);
-#endif
-        }
-    }
-
-    draw_dsc->border_width = lv_obj_get_style_border_width(obj, part);
-    if(draw_dsc->border_width) {
-        if(draw_dsc->border_opa != LV_OPA_TRANSP) {
-            draw_dsc->border_opa = lv_obj_get_style_border_opa(obj, part);
-            if(draw_dsc->border_opa > LV_OPA_MIN) {
-                draw_dsc->border_side = lv_obj_get_style_border_side(obj, part);
-                draw_dsc->border_color = lv_obj_get_style_border_color(obj, part);
-            }
-#if LV_USE_BLEND_MODES
-            draw_dsc->border_blend_mode = lv_obj_get_style_border_blend_mode(obj, part);
-#endif
-        }
-    }
-
-#if LV_USE_OUTLINE
-    draw_dsc->outline_width = lv_obj_get_style_outline_width(obj, part);
-    if(draw_dsc->outline_width) {
-        if(draw_dsc->outline_opa != LV_OPA_TRANSP) {
-            draw_dsc->outline_opa = lv_obj_get_style_outline_opa(obj, part);
-            if(draw_dsc->outline_opa > LV_OPA_MIN) {
-                draw_dsc->outline_pad = lv_obj_get_style_outline_pad(obj, part);
-                draw_dsc->outline_color = lv_obj_get_style_outline_color(obj, part);
-            }
-#if LV_USE_BLEND_MODES
-            draw_dsc->outline_blend_mode = lv_obj_get_style_outline_blend_mode(obj, part);
-#endif
-        }
-    }
-#endif
-
-#if LV_USE_PATTERN
-    draw_dsc->pattern_image = lv_obj_get_style_pattern_image(obj, part);
-    if(draw_dsc->pattern_image) {
-        if(draw_dsc->pattern_opa != LV_OPA_TRANSP) {
-            draw_dsc->pattern_opa = lv_obj_get_style_pattern_opa(obj, part);
-            if(draw_dsc->pattern_opa > LV_OPA_MIN) {
-                draw_dsc->pattern_recolor_opa = lv_obj_get_style_pattern_recolor_opa(obj, part);
-                draw_dsc->pattern_repeat = lv_obj_get_style_pattern_repeat(obj, part);
-                if(lv_img_src_get_type(draw_dsc->pattern_image) == LV_IMG_SRC_SYMBOL) {
-                    draw_dsc->pattern_recolor = lv_obj_get_style_pattern_recolor(obj, part);
-                    draw_dsc->pattern_font = lv_obj_get_style_text_font(obj, part);
-                }
-                else if(draw_dsc->pattern_recolor_opa > LV_OPA_MIN) {
-                    draw_dsc->pattern_recolor = lv_obj_get_style_pattern_recolor(obj, part);
-                }
-#if LV_USE_BLEND_MODES
-                draw_dsc->pattern_blend_mode = lv_obj_get_style_pattern_blend_mode(obj, part);
-#endif
-            }
-        }
-    }
-#endif
-
-#if LV_USE_SHADOW
-    draw_dsc->shadow_width = lv_obj_get_style_shadow_width(obj, part);
-    if(draw_dsc->shadow_width) {
-        if(draw_dsc->shadow_opa > LV_OPA_MIN) {
-            draw_dsc->shadow_opa = lv_obj_get_style_shadow_opa(obj, part);
-            if(draw_dsc->shadow_opa > LV_OPA_MIN) {
-                draw_dsc->shadow_ofs_x = lv_obj_get_style_shadow_ofs_x(obj, part);
-                draw_dsc->shadow_ofs_y = lv_obj_get_style_shadow_ofs_y(obj, part);
-                draw_dsc->shadow_spread = lv_obj_get_style_shadow_spread(obj, part);
-                draw_dsc->shadow_color = lv_obj_get_style_shadow_color(obj, part);
-#if LV_USE_BLEND_MODES
-                draw_dsc->shadow_blend_mode = lv_obj_get_style_shadow_blend_mode(obj, part);
-#endif
-            }
-        }
-    }
-#endif
-
-#if LV_USE_VALUE_STR
-    draw_dsc->value_str = lv_obj_get_style_value_str(obj, part);
-    if(draw_dsc->value_str) {
-        if(draw_dsc->value_opa > LV_OPA_MIN) {
-            draw_dsc->value_opa = lv_obj_get_style_value_opa(obj, part);
-            if(draw_dsc->value_opa > LV_OPA_MIN) {
-                draw_dsc->value_ofs_x = lv_obj_get_style_value_ofs_x(obj, part);
-                draw_dsc->value_ofs_y = lv_obj_get_style_value_ofs_y(obj, part);
-                draw_dsc->value_color = lv_obj_get_style_value_color(obj, part);
-                draw_dsc->value_font = lv_obj_get_style_value_font(obj, part);
-                draw_dsc->value_letter_space = lv_obj_get_style_value_letter_space(obj, part);
-                draw_dsc->value_line_space = lv_obj_get_style_value_line_space(obj, part);
-                draw_dsc->value_align = lv_obj_get_style_value_align(obj, part);
-#if LV_USE_BLEND_MODES
-                draw_dsc->value_blend_mode = lv_obj_get_style_value_blend_mode(obj, part);
-#endif
-            }
-        }
-    }
-#endif
-
-#if LV_USE_OPA_SCALE
-    if(opa_scale < LV_OPA_MAX) {
-        draw_dsc->bg_opa = (uint16_t)((uint16_t)draw_dsc->bg_opa * opa_scale) >> 8;
-        draw_dsc->border_opa = (uint16_t)((uint16_t)draw_dsc->border_opa * opa_scale) >> 8;
-        draw_dsc->shadow_opa = (uint16_t)((uint16_t)draw_dsc->shadow_opa * opa_scale) >> 8;
-        draw_dsc->pattern_opa = (uint16_t)((uint16_t)draw_dsc->pattern_opa * opa_scale) >> 8;
-        draw_dsc->value_opa = (uint16_t)((uint16_t)draw_dsc->value_opa * opa_scale) >> 8;
-    }
-#endif
-}
-
-void lv_obj_init_draw_label_dsc(lv_obj_t * obj, uint8_t part, lv_draw_label_dsc_t * draw_dsc)
-{
-    draw_dsc->opa = lv_obj_get_style_text_opa(obj, part);
-    if(draw_dsc->opa <= LV_OPA_MIN) return;
-
-#if LV_USE_OPA_SCALE
-    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
-    if(opa_scale < LV_OPA_MAX) {
-        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
-    }
-    if(draw_dsc->opa <= LV_OPA_MIN) return;
-#endif
-
-    draw_dsc->color = lv_obj_get_style_text_color(obj, part);
-    draw_dsc->letter_space = lv_obj_get_style_text_letter_space(obj, part);
-    draw_dsc->line_space = lv_obj_get_style_text_line_space(obj, part);
-    draw_dsc->decor = lv_obj_get_style_text_decor(obj, part);
-#if LV_USE_BLEND_MODES
-    draw_dsc->blend_mode = lv_obj_get_style_text_blend_mode(obj, part);
-#endif
-
-    draw_dsc->font = lv_obj_get_style_text_font(obj, part);
-
-    if(draw_dsc->sel_start != LV_DRAW_LABEL_NO_TXT_SEL && draw_dsc->sel_end != LV_DRAW_LABEL_NO_TXT_SEL) {
-        draw_dsc->color = lv_obj_get_style_text_sel_color(obj, part);
-    }
-
-#if LV_USE_BIDI
-    draw_dsc->bidi_dir = lv_obj_get_base_dir(obj);
-#endif
-}
-
-void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint8_t part, lv_draw_img_dsc_t * draw_dsc)
-{
-    draw_dsc->opa = lv_obj_get_style_image_opa(obj, part);
-    if(draw_dsc->opa <= LV_OPA_MIN)  return;
-
-#if LV_USE_OPA_SCALE
-    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
-    if(opa_scale < LV_OPA_MAX) {
-        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
-    }
-    if(draw_dsc->opa <= LV_OPA_MIN)  return;
-#endif
-
-    draw_dsc->angle = 0;
-    draw_dsc->zoom = LV_IMG_ZOOM_NONE;
-    draw_dsc->pivot.x = lv_area_get_width(&obj->coords) / 2;
-    draw_dsc->pivot.y = lv_area_get_height(&obj->coords) / 2;
-
-    draw_dsc->recolor_opa = lv_obj_get_style_image_recolor_opa(obj, part);
-    if(draw_dsc->recolor_opa > 0) {
-        draw_dsc->recolor = lv_obj_get_style_image_recolor(obj, part);
-    }
-#if LV_USE_BLEND_MODES
-    draw_dsc->blend_mode = lv_obj_get_style_image_blend_mode(obj, part);
-#endif
-}
-
-void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t * draw_dsc)
-{
-    draw_dsc->width = lv_obj_get_style_line_width(obj, part);
-    if(draw_dsc->width == 0) return;
-
-    draw_dsc->opa = lv_obj_get_style_line_opa(obj, part);
-    if(draw_dsc->opa <= LV_OPA_MIN)  return;
-
-#if LV_USE_OPA_SCALE
-    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
-    if(opa_scale < LV_OPA_MAX) {
-        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
-    }
-    if(draw_dsc->opa <= LV_OPA_MIN)  return;
-#endif
-
-    draw_dsc->color = lv_obj_get_style_line_color(obj, part);
-
-    draw_dsc->dash_width = lv_obj_get_style_line_dash_width(obj, part);
-    if(draw_dsc->dash_width) {
-        draw_dsc->dash_gap = lv_obj_get_style_line_dash_gap(obj, part);
-    }
-
-    draw_dsc->round_start = lv_obj_get_style_line_rounded(obj, part);
-    draw_dsc->round_end = draw_dsc->round_start;
-
-#if LV_USE_BLEND_MODES
-    draw_dsc->blend_mode = lv_obj_get_style_line_blend_mode(obj, part);
-#endif
-}
-
-/**
- * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
- * @param obj pointer to an object
- * @param part part of the object
- */
-lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part)
-{
-    lv_coord_t s = 0;
-
-    lv_coord_t sh_width = lv_obj_get_style_shadow_width(obj, part);
-    if(sh_width) {
-        lv_opa_t sh_opa = lv_obj_get_style_shadow_opa(obj, part);
-        if(sh_opa > LV_OPA_MIN) {
-            sh_width = sh_width / 2;    /*THe blur adds only half width*/
-            sh_width++;
-            sh_width += lv_obj_get_style_shadow_spread(obj, part);
-            lv_style_int_t sh_ofs_x = lv_obj_get_style_shadow_ofs_x(obj, part);
-            lv_style_int_t sh_ofs_y = lv_obj_get_style_shadow_ofs_y(obj, part);
-            sh_width += LV_MATH_MAX(LV_MATH_ABS(sh_ofs_x), LV_MATH_ABS(sh_ofs_y));
-            s = LV_MATH_MAX(s, sh_width);
-        }
-    }
-
-    const char * value_str = lv_obj_get_style_value_str(obj, part);
-    if(value_str) {
-        lv_opa_t value_opa = lv_obj_get_style_value_opa(obj, part);
-        if(value_opa > LV_OPA_MIN) {
-            lv_style_int_t letter_space = lv_obj_get_style_value_letter_space(obj, part);
-            lv_style_int_t line_space = lv_obj_get_style_value_letter_space(obj, part);
-            const lv_font_t * font = lv_obj_get_style_value_font(obj, part);
-
-            lv_point_t txt_size;
-            _lv_txt_get_size(&txt_size, value_str, font, letter_space, line_space, LV_COORD_MAX, LV_TXT_FLAG_NONE);
-
-            lv_area_t value_area;
-            value_area.x1 = 0;
-            value_area.y1 = 0;
-            value_area.x2 = txt_size.x - 1;
-            value_area.y2 = txt_size.y - 1;
-
-            lv_style_int_t align = lv_obj_get_style_value_align(obj, part);
-            lv_style_int_t xofs = lv_obj_get_style_value_ofs_x(obj, part);
-            lv_style_int_t yofs = lv_obj_get_style_value_ofs_y(obj, part);
-            lv_point_t p_align;
-            _lv_area_align(&obj->coords, &value_area, align, &p_align);
-
-            value_area.x1 += p_align.x + xofs;
-            value_area.y1 += p_align.y + yofs;
-            value_area.x2 += p_align.x + xofs;
-            value_area.y2 += p_align.y + yofs;
-
-            s = LV_MATH_MAX(s, obj->coords.x1 - value_area.x1);
-            s = LV_MATH_MAX(s, obj->coords.y1 - value_area.y1);
-            s = LV_MATH_MAX(s, value_area.x2 - obj->coords.x2);
-            s = LV_MATH_MAX(s, value_area.y2 - obj->coords.y2);
-        }
-    }
-
-    lv_style_int_t outline_width = lv_obj_get_style_outline_width(obj, part);
-    if(outline_width) {
-        lv_opa_t outline_opa = lv_obj_get_style_outline_opa(obj, part);
-        if(outline_opa > LV_OPA_MIN) {
-            lv_style_int_t outline_pad = lv_obj_get_style_outline_pad(obj, part);
-            s = LV_MATH_MAX(s, outline_pad + outline_width);
-        }
-    }
-
-    lv_coord_t w = lv_obj_get_style_transform_width(obj, part);
-    lv_coord_t h = lv_obj_get_style_transform_height(obj, part);
-    lv_coord_t wh = LV_MATH_MAX(w, h);
-    if(wh > 0) s += wh;
-
-    return s;
-}
 
 /**
  * Check if any object has a given type
@@ -1889,7 +1511,7 @@ lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part)
  * @param obj_type type of the object. (e.g. "lv_btn")
  * @return true: valid
  */
-bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type)
+bool _lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type)
 {
     if(obj_type[0] == '\0') return true;
 
@@ -1911,7 +1533,7 @@ bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type)
  * @param obj_type type of the object. (e.g. "lv_btn")
  * @return true: valid
  */
-bool lv_debug_check_obj_valid(const lv_obj_t * obj)
+bool _lv_debug_check_obj_valid(const lv_obj_t * obj)
 {
     lv_disp_t * disp = lv_disp_get_next(NULL);
     while(disp) {
@@ -2086,7 +1708,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
         }
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
-        scrollbar_draw(obj, clip_area);
+        _lv_obj_draw_scrollbar(obj, clip_area);
 
         if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
             lv_draw_mask_radius_param_t * param = lv_draw_mask_remove_custom(obj + 8);
@@ -2118,7 +1740,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
         /*Draw the grid cells*/
         if(obj->grid) {
             _lv_grid_calc_t calc;
-            grid_calc(obj, &calc);
+            _lv_grid_calc(obj, &calc);
 
             /*Create a color unique to this object. */
             lv_color_t c = lv_color_hex(((lv_uintptr_t) obj) & 0xFFFFFF);
@@ -2151,7 +1773,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             }
 
 
-            grid_calc_free(&calc);
+            _lv_grid_calc_free(&calc);
         }
 #endif
     }
@@ -2189,7 +1811,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         else info->result = NULL;
         return LV_RES_OK;
     }
-    else if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    else if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_res_t res = LV_RES_OK;
 
@@ -2197,7 +1819,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
            (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
         {
-            lv_grid_full_refr(obj);
+            _lv_grid_full_refresh(obj);
         }
     }
     else if(sign == LV_SIGNAL_CHILD_CHG) {
@@ -2208,9 +1830,9 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if(obj->grid) {
             lv_obj_t * child = param;
             if(child) {
-                if(_lv_obj_is_grid_item(child)) lv_grid_full_refr(obj);
+                if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
             } else {
-                lv_grid_full_refr(obj);
+                _lv_grid_full_refresh(obj);
             }
         }
     }
@@ -2225,11 +1847,11 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        lv_coord_t d = lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
+        lv_coord_t d = 0;//_lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
-        if(_lv_obj_is_grid_item(obj)) lv_grid_full_refr(obj);
+        if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
 
         lv_obj_t * child = lv_obj_get_child(obj, NULL);
         while(child) {
@@ -2243,8 +1865,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
-//        if(lv_obj_is_grid_item(obj)) lv_grid_full_refr(lv_obj_get_parent(obj));
-        lv_obj_refresh_ext_draw_pad(obj);
+        _lv_obj_refresh_ext_draw_pad(obj);
     }
     else if(sign == LV_SIGNAL_PRESSED) {
         lv_obj_add_state(obj, LV_STATE_PRESSED);
@@ -2262,14 +1883,14 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
             state |= LV_STATE_EDITED;
 
             /*if using focus mode, change target to parent*/
-            obj = lv_obj_get_focused_obj(obj);
+            obj = _lv_obj_get_focused_obj(obj);
 
             lv_obj_add_state(obj, state);
         }
         else {
 
             /*if using focus mode, change target to parent*/
-            obj = lv_obj_get_focused_obj(obj);
+            obj = _lv_obj_get_focused_obj(obj);
 
             lv_obj_add_state(obj, LV_STATE_FOCUSED);
             lv_obj_clear_state(obj, LV_STATE_EDITED);
@@ -2278,7 +1899,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_DEFOCUS) {
 
         /*if using focus mode, change target to parent*/
-        obj = lv_obj_get_focused_obj(obj);
+        obj = _lv_obj_get_focused_obj(obj);
 
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
@@ -2314,168 +1935,3 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 
     return false;
 }
-
-
-static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
-{
-    lv_draw_rect_dsc_init(dsc);
-    dsc->bg_opa = lv_obj_get_style_scrollbar_bg_opa(obj, LV_OBJ_PART_MAIN);
-    if(dsc->bg_opa > LV_OPA_MIN) {
-        dsc->bg_color = lv_obj_get_style_scrollbar_bg_color(obj, LV_OBJ_PART_MAIN);
-    }
-
-    dsc->border_opa = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
-    if(dsc->border_opa > LV_OPA_MIN) {
-        dsc->border_width = lv_obj_get_style_scrollbar_border_width(obj, LV_OBJ_PART_MAIN);
-        if(dsc->border_width > 0) {
-            dsc->border_color = lv_obj_get_style_scrollbar_border_color(obj, LV_OBJ_PART_MAIN);
-        } else {
-            dsc->border_opa = LV_OPA_TRANSP;
-        }
-    }
-
-    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP) {
-        dsc->radius = lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
-        return LV_RES_OK;
-    } else {
-        return LV_RES_INV;
-    }
-}
-
-static void scrollbar_draw(lv_obj_t * obj, const lv_area_t * clip_area)
-{
-    lv_scroll_dir_t sm = lv_obj_get_scroll_mode(obj);
-    if(sm == LV_SCROLL_MODE_OFF) {
-        return;
-    }
-
-    lv_coord_t st = lv_obj_get_scroll_top(obj);
-    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
-    lv_coord_t sl = lv_obj_get_scroll_left(obj);
-    lv_coord_t sr = lv_obj_get_scroll_right(obj);
-
-    /*Return if too small content to scroll*/
-    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sr <= 0) {
-        return;
-    }
-
-    /*If there is no indev scrolling this object but the moe is active return*/
-    lv_indev_t * indev = lv_indev_get_next(NULL);
-    if(sm == LV_SCROLL_MODE_ACTIVE) {
-        bool found = false;
-        while(indev) {
-            if(lv_indev_get_scroll_obj(indev) == obj) {
-                found = true;
-                break;
-            }
-            indev = lv_indev_get_next(indev);
-        }
-        if(!found) {
-            return;
-        }
-    }
-
-    lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t tickness = lv_obj_get_style_scrollbar_tickness(obj, LV_OBJ_PART_MAIN);
-
-    lv_coord_t obj_h = lv_obj_get_height(obj);
-    lv_coord_t obj_w = lv_obj_get_width(obj);
-
-    bool ver_draw = false;
-    if((sm == LV_SCROLL_MODE_ON) ||
-       (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
-       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER)) {
-        ver_draw = true;
-    }
-
-    bool hor_draw = false;
-    if((sm == LV_SCROLL_MODE_ON) ||
-       (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
-       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR)) {
-        hor_draw = true;
-    }
-
-    lv_coord_t ver_reg_space = ver_draw ? tickness + side_space : 0;
-    lv_coord_t hor_req_space = hor_draw ? tickness + side_space : 0;
-    lv_coord_t rem;
-
-    lv_draw_rect_dsc_t draw_dsc;
-    lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
-    if(sb_res != LV_RES_OK) return;
-
-    lv_area_t area;
-    area.y1 = obj->coords.y1;
-    area.y2 = obj->coords.y2;
-    area.x2 = obj->coords.x2 - side_space;
-    area.x1 = area.x2 - tickness;
-
-    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
-    if(ver_draw && _lv_area_is_on(&area, clip_area)) {
-        lv_coord_t content_h = obj_h + st + sb;
-        lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
-        sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
-        rem = (obj_h - end_space * 2 - hor_req_space) - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
-        lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
-        if(scroll_h <= 0) {
-            area.y1 = obj->coords.y1 + end_space;
-            area.y2 = obj->coords.y2 - end_space - hor_req_space - 1;
-            area.x2 = obj->coords.x2 - side_space;
-            area.x1 = area.x2 - tickness + 1;
-        } else {
-            lv_coord_t sb_y = (rem * sb) / scroll_h;
-            sb_y = rem - sb_y;
-
-            area.y1 = obj->coords.y1 + sb_y + end_space;
-            area.y2 = area.y1 + sb_h - 1;
-            area.x2 = obj->coords.x2 - side_space;
-            area.x1 = area.x2 - tickness;
-            if(area.y1 < obj->coords.y1 + end_space) {
-                area.y1 = obj->coords.y1 + end_space;
-                if(area.y1 + SCROLLBAR_MIN_SIZE > area.y2) area.y2 = area.y1 + SCROLLBAR_MIN_SIZE;
-            }
-            if(area.y2 > obj->coords.y2 - hor_req_space - end_space) {
-                area.y2 = obj->coords.y2 - hor_req_space - end_space;
-                if(area.y2 - SCROLLBAR_MIN_SIZE < area.y1) area.y1 = area.y2 - SCROLLBAR_MIN_SIZE;
-            }
-        }
-        lv_draw_rect(&area, clip_area, &draw_dsc);
-    }
-
-    area.y2 = obj->coords.y2 - side_space;
-    area.y1 =area.y2 - tickness;
-    area.x1 = obj->coords.x1;
-    area.x2 = obj->coords.x2;
-    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
-    if(hor_draw && _lv_area_is_on(&area, clip_area)) {
-        lv_coord_t content_w = obj_w + sl + sr;
-        lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
-        sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
-        rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
-        lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
-        if(scroll_w <= 0) {
-            area.y2 = obj->coords.y2 - side_space;
-            area.y1 = area.y2 - tickness + 1;
-            area.x1 = obj->coords.x1 + end_space;
-            area.x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
-        } else {
-            lv_coord_t sb_x = (rem * sr) / scroll_w;
-            sb_x = rem - sb_x;
-
-            area.x1 = obj->coords.x1 + sb_x + end_space;
-            area.x2 = area.x1 + sb_w - 1;
-            area.y2 = obj->coords.y2 - side_space;
-            area.y1 = area.y2 - tickness;
-            if(area.x1 < obj->coords.x1 + end_space) {
-                area.x1 = obj->coords.x1 + end_space;
-                if(area.x1 + SCROLLBAR_MIN_SIZE > area.x2) area.x2 = area.x1 + SCROLLBAR_MIN_SIZE;
-            }
-            if(area.x2 > obj->coords.x2 - ver_reg_space - end_space) {
-                area.x2 = obj->coords.x2 - ver_reg_space - end_space;
-                if(area.x2 - SCROLLBAR_MIN_SIZE < area.x1) area.x1 = area.x2 - SCROLLBAR_MIN_SIZE;
-            }
-        }
-        lv_draw_rect(&area, clip_area, &draw_dsc);
-    }
-}
-
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 7e99a647e..4fff3710b 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -57,7 +57,6 @@ extern "C" {
 
 struct _lv_obj_t;
 
-
 /** Design modes */
 enum {
     LV_DESIGN_DRAW_MAIN, /**< Draw the main portion of the object */
@@ -196,12 +195,15 @@ enum {
     LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 7),
     LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 8),
     LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 9),
+    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 10),
 };
 typedef uint16_t lv_obj_flag_t;
 
 
 #include "lv_obj_pos.h"
 #include "lv_obj_scroll.h"
+#include "lv_obj_style.h"
+#include "lv_obj_draw.h"
 
 
 typedef struct _lv_obj_t {
@@ -219,8 +221,7 @@ typedef struct _lv_obj_t {
     lv_style_list_t  style_list;
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    uint8_t ext_click_pad_hor; /**< Extra click padding in horizontal direction */
-    uint8_t ext_click_pad_ver; /**< Extra click padding in vertical direction */
+    uint8_t ext_click_pad; /**< Extra click padding in all direction */
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
     lv_area_t ext_click_pad;   /**< Extra click padding area. */
 #endif
@@ -228,13 +229,12 @@ typedef struct _lv_obj_t {
     lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 
     /*Attributes and states*/
-    lv_obj_flag_t flags     : 9;
+    lv_obj_flag_t flags;
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
     lv_scroll_snap_align_t snap_align_x : 2;
     lv_scroll_snap_align_t snap_align_y : 2;
     lv_scroll_dir_t scroll_dir :4;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
-    uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
 
     lv_state_t state;
 
@@ -426,13 +426,6 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
  * Attribute set
  *----------------*/
 
-/**
- * Set whether advanced hit-testing is enabled on an object
- * @param obj pointer to an object
- * @param en true: advanced hit-testing is enabled
- */
-void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en);
-
 /**
  * Set the base direction of the object
  * @param obj pointer to an object
@@ -441,6 +434,7 @@ void lv_obj_set_adv_hittest(lv_obj_t * obj, bool en);
 void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir);
 
 void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f);
+
 void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f);
 
 /**
@@ -528,7 +522,6 @@ const void * lv_event_get_data(void);
  */
 void lv_obj_set_signal_cb(lv_obj_t * obj, lv_signal_cb_t signal_cb);
 
-
 /**
  * Send an event to the object
  * @param obj pointer to an object
@@ -556,13 +549,6 @@ void lv_obj_set_design_cb(lv_obj_t * obj, lv_design_cb_t design_cb);
  */
 void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size);
 
-/**
- * Send a 'LV_SIGNAL_REFR_EXT_SIZE' signal to the object to refresh the extended draw area.
- * he object needs to be invalidated by `lv_obj_invalidate(obj)` manually after this function.
- * @param obj pointer to an object
- */
-void lv_obj_refresh_ext_draw_pad(lv_obj_t * obj);
-
 /*=======================
  * Getter functions
  *======================*/
@@ -627,59 +613,37 @@ uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj);
  *--------------------*/
 
 /**
- * Get the left padding of extended clickable area
+ * Get the extended extended clickable area in a direction
  * @param obj pointer to an object
+ * @param dir in which direction get the extended area (`LV_DIR_LEFT/RIGHT/TOP`)
  * @return the extended left padding
  */
-lv_coord_t lv_obj_get_ext_click_pad_left(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir);
+
 
 /**
- * Get the right padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended right padding
+ * Check if a given screen-space point is on an object's coordinates.
+ * This method is intended to be used mainly by advanced hit testing algorithms to check
+ * whether the point is even within the object (as an optimization).
+ * @param obj object to check
+ * @param point screen-space point
  */
-lv_coord_t lv_obj_get_ext_click_pad_right(const lv_obj_t * obj);
+bool _lv_obj_is_click_point_on(lv_obj_t * obj, const lv_point_t * point);
 
 /**
- * Get the top padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended top padding
+ * Hit-test an object given a particular point in screen space.
+ * @param obj object to hit-test
+ * @param point screen-space point
+ * @return true if the object is considered under the point
  */
-lv_coord_t lv_obj_get_ext_click_pad_top(const lv_obj_t * obj);
-
-/**
- * Get the bottom padding of extended clickable area
- * @param obj pointer to an object
- * @return the extended bottom padding
- */
-lv_coord_t lv_obj_get_ext_click_pad_bottom(const lv_obj_t * obj);
-
-/**
- * Get the extended size attribute of an object
- * @param obj pointer to an object
- * @return the extended size attribute
- */
-lv_coord_t lv_obj_get_ext_draw_pad(const lv_obj_t * obj);
-
-/*-----------------
- * Appearance get
- *---------------*/
-
+bool lv_obj_hit_test(lv_obj_t * obj, lv_point_t * point);
 
 /*-----------------
  * Attribute get
  *----------------*/
 
-
 bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f);
 
-/**
- * Get whether advanced hit-testing is enabled on an object
- * @param obj pointer to an object
- * @return true: advanced hit-testing is enabled
- */
-bool lv_obj_get_adv_hittest(const lv_obj_t * obj);
-
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj);
 
 lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part);
@@ -709,23 +673,13 @@ lv_event_cb_t lv_obj_get_event_cb(const lv_obj_t * obj);
  * Other get
  *-----------------*/
 
-/**
- * Check if a given screen-space point is on an object's coordinates.
- *
- * This method is intended to be used mainly by advanced hit testing algorithms to check
- * whether the point is even within the object (as an optimization).
- * @param obj object to check
- * @param point screen-space point
- */
-bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point);
-
 /**
  * Hit-test an object given a particular point in screen space.
  * @param obj object to hit-test
  * @param point screen-space point
  * @return true if the object is considered under the point
  */
-bool lv_obj_hittest(lv_obj_t * obj, lv_point_t * point);
+bool lv_obj_hit_test(lv_obj_t * obj, lv_point_t * point);
 
 /**
  * Get the ext pointer
@@ -786,7 +740,7 @@ bool lv_obj_is_focused(const lv_obj_t * obj);
  * @param obj the start object
  * @return the object to really focus
  */
-lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj);
+lv_obj_t * _lv_obj_get_focused_obj(const lv_obj_t * obj);
 
 /*-------------------
  * OTHER FUNCTIONS
@@ -798,30 +752,7 @@ lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj);
  * @param name name of the object. E.g. "lv_btn". (Only the pointer is saved)
  * @return LV_RES_OK
  */
-lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name);
-
-/**
- * Initialize a rectangle descriptor from an object's styles
- * @param obj pointer to an object
- * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_SLIDER_KOB`
- * @param draw_dsc the descriptor the initialize
- * @note Only the relevant fields will be set.
- * E.g. if `border width == 0` the other border properties won't be evaluated.
- */
-void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t type, lv_draw_rect_dsc_t * draw_dsc);
-
-void lv_obj_init_draw_label_dsc(lv_obj_t * obj, uint8_t type, lv_draw_label_dsc_t * draw_dsc);
-
-void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint8_t part, lv_draw_img_dsc_t * draw_dsc);
-
-void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t * draw_dsc);
-
-/**
- * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
- * @param obj pointer to an object
- * @param part part of the object
- */
-lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part);
+lv_res_t _lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name);
 
 
 /**
@@ -830,7 +761,7 @@ lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part);
  * @param obj_type type of the object. (e.g. "lv_btn")
  * @return true: valid
  */
-bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
+bool _lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
 
 /**
  * Check if any object is still "alive", and part of the hierarchy
@@ -838,11 +769,7 @@ bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
  * @param obj_type type of the object. (e.g. "lv_btn")
  * @return true: valid
  */
-bool lv_debug_check_obj_valid(const lv_obj_t * obj);
-
-void _lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff);
-
-#include "lv_obj_style.h"
+bool _lv_debug_check_obj_valid(const lv_obj_t * obj);
 
 /**********************
  *      MACROS
@@ -869,8 +796,8 @@ void _lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_di
 
 # ifndef LV_DEBUG_IS_OBJ
 #  define LV_DEBUG_IS_OBJ(obj_p, obj_type) (lv_debug_check_null(obj_p) &&      \
-                                            lv_debug_check_obj_valid(obj_p) && \
-                                            lv_debug_check_obj_type(obj_p, obj_type))
+                                            _lv_debug_check_obj_valid(obj_p) && \
+                                            _lv_debug_check_obj_type(obj_p, obj_type))
 # endif
 
 
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index ec9c17dfe..247cb108e 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -11,6 +11,7 @@
 /*********************
  *      DEFINES
  *********************/
+#define LV_OBJX_NAME "lv_obj"
 
 /**********************
  *      TYPEDEFS
@@ -61,30 +62,29 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     }
 
     /*If not grid item but has grid position set the position to 0*/
-    if(!gi) {
-        if(_GRID_IS_CELL(x)) {
-            obj->x_set = 0;
-            x = 0;
-        }
-        if(_GRID_IS_CELL(y)) {
-            obj->y_set = 0;
-            y = 0;
-        }
-    }
+//    if(!gi) {
+//        if(_GRID_IS_CELL(x)) {
+//            obj->x_set = 0;
+//            x = 0;
+//        }
+//        if(_GRID_IS_CELL(y)) {
+//            obj->y_set = 0;
+//            y = 0;
+//        }
+//    }
 
     /*If the object is on a grid item let the grid to position it. */
     if(gi) {
-        lv_area_t old_area;
-        lv_area_copy(&old_area, &obj->coords);
-        lv_grid_item_refr_pos(obj);
-
         lv_obj_t * cont = lv_obj_get_parent(obj);
 
-        /*If the item was moved and grid is implicit in the changed direction refresh the whole grid.*/
-        if((cont->grid->col_dsc == NULL && (old_area.x1 != obj->coords.x1 || old_area.x2 != obj->coords.x2)) ||
-           (cont->grid->row_dsc == NULL && (old_area.y1 != obj->coords.y1 || old_area.y2 != obj->coords.y2)))
+        /*If the item was moved on an implicit grid the whole grid can change so refresh the full grid.*/
+        if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL)
         {
-            lv_grid_full_refr(cont);
+            _lv_grid_full_refresh(cont);
+        }
+        /*On explicit grids the grid itself doesn't depend on the items, so just position the item*/
+        else {
+            lv_grid_item_refr_pos(obj);
         }
     } else {
         _lv_obj_move_to(obj, x, y, true);
@@ -442,40 +442,6 @@ lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
     return lv_obj_get_width(obj) + mleft + mright;
 }
 
-/**
- * Check if a given screen-space point is on an object's coordinates.
- *
- * This method is intended to be used mainly by advanced hit testing algorithms to check
- * whether the point is even within the object (as an optimization).
- * @param obj object to check
- * @param point screen-space point
- */
-bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point)
-{
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad_hor;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad_hor;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad_ver;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad_ver;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
-#else
-    if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
-#endif
-        return false;
-    }
-    return true;
-}
-
 /**
  * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
  * @param obj pointer to an object
@@ -486,6 +452,8 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
 {
     if(!w_out && !h_out) return;
 
+//    printf("auto size\n");
+
     /*If no other effect the auto-size of zero by default*/
     if(w_out) *w_out = 0;
     if(h_out) *h_out = 0;
@@ -495,10 +463,10 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
     lv_coord_t grid_h = 0;
     if(obj->grid) {
         _lv_grid_calc_t calc;
-        grid_calc(obj, &calc);
+        _lv_grid_calc(obj, &calc);
         grid_w = calc.col_dsc[calc.col_dsc_len - 1] + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
         grid_h = calc.row_dsc[calc.row_dsc_len - 1] + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);;
-        grid_calc_free(&calc);
+        _lv_grid_calc_free(&calc);
     }
 
     /*Get the children's most right and bottom position*/
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
index d7363c5e4..8dd4d94d2 100644
--- a/src/lv_core/lv_obj_pos.h
+++ b/src/lv_core/lv_obj_pos.h
@@ -22,10 +22,7 @@ extern "C" {
 /**********************
  *      TYPEDEFS
  **********************/
-
-/* Can't include lv_obj.h because it includes this header file */
 struct _lv_obj_t;
-typedef struct _lv_obj_t lv_obj_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -34,79 +31,82 @@ typedef struct _lv_obj_t lv_obj_t;
 /**
  * Set relative the position of an object (relative to the parent)
  * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
+ * @param x new distance from the left side of the parent plus the parent's left padding or a grid cell
+ * @param y new distance from the top side of the parent  plus the parent's right padding or a grid cell
+ * @note Zero value value means place the object is on the left padding of the parent, and not on the left edge.
+ * @note A grid cell can be and explicit placement with cell position and span:
+ *         `LV_GRID_CELL_START/END/CENTER/STRETCH(pos, span)`
+ *       or "auto" to place the object on the grid in the creation order of other children
+ *       `LV_GRID_AUTO_START/END/CENTER/STRETCH`
+ * @note to use grid placement the parent needs have a defined grid with `lv_obj_set_grid`
  */
-void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+void lv_obj_set_pos(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
 
 /**
  * Set the x coordinate of a object
  * @param obj pointer to an object
- * @param x new distance from the left side from the parent
+ * @param x new distance from the left side from the parent plus the parent's left padding or a grid cell
  */
-void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x);
+void lv_obj_set_x(struct _lv_obj_t * obj, lv_coord_t x);
 
 /**
  * Set the y coordinate of a object
  * @param obj pointer to an object
- * @param y new distance from the top of the parent
+ * @param y new distance from the top of the parent  plus the parent's top padding or a grid cell
  */
-void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y);
-
-
-void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h);
+void lv_obj_set_y(struct _lv_obj_t * obj, lv_coord_t y);
 
 /**
- * Set the size of an object
+ * Set the size of an object.
  * @param obj pointer to an object
- * @param w new width
- * @param h new height
+ * @param w new width in pixels or `LV_SIZE_AUTO` to set the size to involve all children
+ * @param h new height  in pixels or `LV_SIZE_AUTO` to set the size to involve all children
  */
-void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h);
+void lv_obj_set_size(struct _lv_obj_t * obj, lv_coord_t w, lv_coord_t h);
 
 /**
  * Set the width of an object
  * @param obj pointer to an object
- * @param w new width
+ * @param w new width in pixels or `LV_SIZE_AUTO` to set the size to involve all children
  */
-void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w);
+void lv_obj_set_width(struct _lv_obj_t * obj, lv_coord_t w);
 
 /**
  * Set the height of an object
  * @param obj pointer to an object
- * @param h new height
+ * @param h new height in pixels or `LV_SIZE_AUTO` to set the size to involve all children
  */
-void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h);
+void lv_obj_set_height(struct _lv_obj_t * obj, lv_coord_t h);
 
 /**
  * Set the width reduced by the left and right padding.
  * @param obj pointer to an object
- * @param w the width without paddings
+ * @param w the width without paddings in pixels
  */
-void lv_obj_set_content_width(lv_obj_t * obj, lv_coord_t w);
+void lv_obj_set_content_width(struct _lv_obj_t * obj, lv_coord_t w);
 
 /**
  * Set the height reduced by the top and bottom padding.
  * @param obj pointer to an object
- * @param h the height without paddings
+ * @param h the height without paddings in pixels
  */
-void lv_obj_set_content_height(lv_obj_t * obj, lv_coord_t h);
+void lv_obj_set_content_height(struct _lv_obj_t * obj, lv_coord_t h);
 
 /**
  * Set the width of an object by taking the left and right margin into account.
  * The object width will be `obj_w = w - margin_left - margin_right`
  * @param obj pointer to an object
- * @param w new height including margins
+ * @param w new height including margins in pixels
  */
-void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w);
+void lv_obj_set_width_margin(struct _lv_obj_t * obj, lv_coord_t w);
 
 /**
  * Set the height of an object by taking the top and bottom margin into account.
  * The object height will be `obj_h = h - margin_top - margin_bottom`
  * @param obj pointer to an object
- * @param h new height including margins
+ * @param h new height including margins in pixels
  */
-void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
+void lv_obj_set_height_margin(struct _lv_obj_t * obj, lv_coord_t h);
 
 /**
  * Align an object to an other object.
@@ -116,120 +116,120 @@ void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
  * @param x_ofs x coordinate offset after alignment
  * @param y_ofs y coordinate offset after alignment
  */
-void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
-
+void lv_obj_align(struct _lv_obj_t * obj, const struct _lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
 
 /**
  * Copy the coordinates of an object to an area
  * @param obj pointer to an object
- * @param cords_p pointer to an area to store the coordinates
+ * @param coords_out pointer to an area to store the coordinates
  */
-void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * cords_p);
+void lv_obj_get_coords(const struct _lv_obj_t * obj, lv_area_t * coords_out);
 
 /**
  * Reduce area retried by `lv_obj_get_coords()` the get graphically usable area of an object.
  * (Without the size of the border or other extra graphical elements)
- * @param coords_p store the result area here
+ * @param coords_out store the result area here
  */
-void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p);
+void lv_obj_get_inner_coords(const struct _lv_obj_t * obj, lv_area_t * coords_out);
 
 /**
- * Get the x coordinate of object
+ * Get the x coordinate of object.
  * @param obj pointer to an object
- * @return distance of 'obj' from the left side of its parent
+ * @return distance of 'obj' from the left side of its parent plus the parent's left padding
+ * @note Zero return value means the object is on the left padding of the parent, and not on the left edge.
+ * @note Scrolling of the parent doesn't change the returned value.
+ * @note The returned value is always the distance from the parent even if the position is grid cell or other special value.
  */
-lv_coord_t lv_obj_get_x(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_x(const struct _lv_obj_t * obj);
 
 /**
- * Get the y coordinate of object
+ * Get the y coordinate of object.
  * @param obj pointer to an object
- * @return distance of 'obj' from the top of its parent
+ * @return distance of 'obj' from the top side of its parent plus the parent's top padding
+ * @note Zero return value means the object is on the top padding of the parent, and not on the top edge.
+ * @note Scrolling of the parent doesn't change the returned value.
+ * @note The returned value is always the distance from the parent even if the position is grid cell or other special value.
  */
-lv_coord_t lv_obj_get_y(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_y(const struct _lv_obj_t * obj);
 
 /**
  * Get the width of an object
  * @param obj pointer to an object
- * @return the width
+ * @return the width in pixels
+ * @note The returned value is always the width in pixels even if the width is set to `LV_SIZE_AUTO` or other special value.
  */
-lv_coord_t lv_obj_get_width(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_width(const struct _lv_obj_t * obj);
 
 /**
  * Get the height of an object
  * @param obj pointer to an object
- * @return the height
+ * @return the height in pixels
+ * @note The returned value is always the width in pixels even if the width is set to `LV_SIZE_AUTO` or other special value.
  */
-lv_coord_t lv_obj_get_height(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_height(const struct _lv_obj_t * obj);
 
 /**
  * Get that width reduced by the left and right padding.
  * @param obj pointer to an object
- * @return the width which still fits into the container
+ * @return the width which still fits into the container without causing overflow
  */
-lv_coord_t lv_obj_get_width_fit(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_width_fit(const struct _lv_obj_t * obj);
 
 /**
  * Get that height reduced by the top an bottom padding.
  * @param obj pointer to an object
- * @return the height which still fits into the container
+ * @return the height which still fits into the container without causing overflow
  */
-lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_height_fit(const struct _lv_obj_t * obj);
 
 /**
  * Get the height of an object by taking the top and bottom margin into account.
  * The returned height will be `obj_h + margin_top + margin_bottom`
  * @param obj pointer to an object
- * @return the height including thee margins
+ * @return the height including the margins
  */
-lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj);
+lv_coord_t lv_obj_get_height_margin(struct _lv_obj_t * obj);
 
 /**
  * Get the width of an object by taking the left and right margin into account.
  * The returned width will be `obj_w + margin_left + margin_right`
  * @param obj pointer to an object
- * @return the height including thee margins
+ * @return the height including the margins
  */
-lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj);
-
+lv_coord_t lv_obj_get_width_margin(struct _lv_obj_t * obj);
 
 /**
- * Check if a given screen-space point is on an object's coordinates.
- *
- * This method is intended to be used mainly by advanced hit testing algorithms to check
- * whether the point is even within the object (as an optimization).
- * @param obj object to check
- * @param point screen-space point
- */
-bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point);
-
-/**
- * Divide the width of the object and get the width of a given number of columns.
- * Take paddings into account.
+ * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
  * @param obj pointer to an object
- * @param div indicates how many columns are assumed.
- * If 1 the width will be set the the parent's width
- * If 2 only half parent width - inner padding of the parent
- * If 3 only third parent width - 2 * inner padding of the parent
- * @param span how many columns are combined
- * @return the width according to the given parameters
+ * @param w_out store the width here. NULL to not calculate width
+ * @param h_out store the height here. NULL to not calculate height
  */
-lv_coord_t lv_obj_get_width_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
+void _lv_obj_calc_auto_size(struct _lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_out);
 
 /**
- * Divide the height of the object and get the width of a given number of columns.
- * Take paddings into account.
- * @param obj pointer to an object
- * @param div indicates how many rows are assumed.
- * If 1 the height will be set the the parent's height
- * If 2 only half parent height - inner padding of the parent
- * If 3 only third parent height - 2 * inner padding of the parent
- * @param span how many rows are combined
- * @return the height according to the given parameters
+ * Move an object to a given x and y coordinate.
+ * It's the core function to move objects but user should use `lv_obj_set_pos/x/y/..` etc.
+ * @param obj pointer to an object to move
+ * @param x the new x coordinate in pixels
+ * @param y the new y coordinate in pixels
+ * @param notify_parent true: send `LV_SIGNAL_CHILD_CHG` to the parent if `obj` moved; false: do not notify the parent
  */
-lv_coord_t lv_obj_get_height_grid(lv_obj_t * obj, uint8_t div, uint8_t span);
+void _lv_obj_move_to(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent);
 
-void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent);
+/**
+ * Reposition the children of an object. (Called recursively)
+ * @param obj pointer to an object which children will be repositioned
+ * @param x_diff x coordinate shift
+ * @param y_diff y coordinate shift
+ */
+void _lv_obj_move_children_by(struct _lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff);
 
+/**
+ * Check if an object is valid grid item or not.
+ * @param obj pointer to an object to check
+ * @return true: grid item; false: not grid item
+ */
+bool _lv_obj_is_grid_item(struct _lv_obj_t * obj);
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 4d94a5ba0..83ce66cce 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -12,6 +12,7 @@
 /*********************
  *      DEFINES
  *********************/
+#define LV_OBJX_NAME "lv_obj"
 #define SCROLL_ANIM_TIME_MIN 100    /*ms*/
 #define SCROLL_ANIM_TIME_MAX 300    /*ms*/
 
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index fa5ab753d..bb7987132 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -25,7 +25,6 @@ extern "C" {
  **********************/
 
 struct _lv_obj_t;
-typedef struct _lv_obj_t lv_obj_t;
 
 /** Scrollbar modes: shows when should the scrollbars be visible*/
 enum {
@@ -54,14 +53,14 @@ typedef uint8_t lv_scroll_snap_align_t;
  * @param obj pointer to an object
  * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
  */
-void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode);
+void lv_obj_set_scroll_mode(struct _lv_obj_t * obj, lv_scroll_mode_t mode);
 
 /**
  * Get how the scrollbars should behave.
  * @param obj pointer to an object
  * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
  */
-lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj);
+lv_scroll_mode_t lv_obj_get_scroll_mode(struct _lv_obj_t * obj);
 
 /**
  * Moves all children with horizontally or vertically.
@@ -70,7 +69,7 @@ lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj);
  * @param x pixel to move horizontally
  * @param y pixels to move vertically
  */
-void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+void _lv_obj_scroll_by_raw(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
 
 /**
  * Moves all children with horizontally or vertically.
@@ -79,7 +78,7 @@ void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
  * @param x pixel to move horizontally
  * @param y pixels to move vertically
  */
-void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+void lv_obj_scroll_by(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
 
 /**
  * Scroll the a given x coordinate to the left side of obj.
@@ -87,21 +86,21 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  * @param x the x coordinate to scroll to
  * @param y the y coordinate to scroll to
  */
-void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+void lv_obj_scroll_to(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
 
 /**
  * Scroll the a given x coordinate to the left side of obj.
  * @param obj pointer to an object which should be scrolled
  * @param x the x coordinate to scroll to
  */
-void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
+void lv_obj_scroll_to_x(struct _lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
 
 /**
  * Scroll the a given y coordinate to the top side of obj.
  * @param obj pointer to an object which should be scrolled
  * @param y the y coordinate to scroll to
  */
-void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
+void lv_obj_scroll_to_y(struct _lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
 
 
 /**
@@ -111,7 +110,7 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_top(const struct _lv_obj_t * obj);
 
 /**
  * Return the height of the area below the parent.
@@ -120,7 +119,7 @@ lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_bottom(const struct _lv_obj_t * obj);
 
 
 /**
@@ -130,7 +129,7 @@ lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_left(const struct _lv_obj_t * obj);
 
 /**
  * Return the width of the area below the object.
@@ -139,7 +138,7 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_right(const struct _lv_obj_t * obj);
 
 
 /**********************
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index 9fa0be8b9..54355189d 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -18,6 +18,7 @@
 /*********************
  *      DEFINES
  *********************/
+#define LV_OBJX_NAME "lv_obj"
 
 /**********************
  *      TYPEDEFS
@@ -53,10 +54,12 @@ static void trans_anim_start_cb(lv_anim_t * a);
 static void trans_anim_ready_cb(lv_anim_t * a);
 #endif
 
+#if LV_STYLE_CACHE_LEVEL >= 1
 static bool style_prop_is_cacheable(lv_style_property_t prop);
 static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop);
 static void update_style_cache_children(lv_obj_t * obj);
 static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+#endif
 static void fade_anim_cb(lv_obj_t * obj, lv_anim_value_t v);
 static void fade_in_anim_ready(lv_anim_t * a);
 
@@ -251,6 +254,7 @@ lv_style_list_t * _lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part)
  */
 void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
 {
+#if LV_STYLE_CACHE_LEVEL >= 1
     uint8_t part;
     for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
         lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
@@ -262,6 +266,10 @@ void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
         if(list == NULL) break;
         list->ignore_cache = dis;
     }
+#else
+    LV_UNUSED(obj);
+    LV_UNUSED(dis);
+#endif
 }
 
 
@@ -291,14 +299,12 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
     const lv_obj_t * parent = obj;
     while(parent) {
         lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
+#if LV_STYLE_CACHE_LEVEL >= 1
         if(!list->ignore_cache && list->style_cnt > 0) {
             if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
 
             bool def = false;
             switch(prop  & (~LV_STYLE_STATE_MASK)) {
-                case LV_STYLE_BG_GRAD_DIR:
-                    if(list->bg_grad_dir_none) def = true;
-                    break;
                 case LV_STYLE_CLIP_CORNER:
                     if(list->clip_corner_off) def = true;
                     break;
@@ -331,8 +337,16 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
                     if(list->shadow_width_zero) def = true;
                     break;
                 case LV_STYLE_PAD_TOP:
+                    if(list->pad_all_zero) def = true;
+                    else if(list->pad_top) return list->pad_top;
+                    break;
                 case LV_STYLE_PAD_BOTTOM:
+                    if(list->pad_all_zero) def = true;
+                    break;
                 case LV_STYLE_PAD_LEFT:
+                    if(list->pad_all_zero) def = true;
+                    else if(list->pad_left) return list->pad_left;
+                    break;
                 case LV_STYLE_PAD_RIGHT:
                     if(list->pad_all_zero) def = true;
                     break;
@@ -359,6 +373,7 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
                 break;
             }
         }
+#endif
 
         lv_state_t state = lv_obj_get_state(parent, part);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
@@ -480,7 +495,7 @@ lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_prop
     const lv_obj_t * parent = obj;
     while(parent) {
         lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
-
+#if LV_STYLE_CACHE_LEVEL >= 1
         if(!list->ignore_cache && list->style_cnt > 0) {
             if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
             bool def = false;
@@ -501,7 +516,7 @@ lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_prop
                 break;
             }
         }
-
+#endif
 
         lv_state_t state = lv_obj_get_state(parent, part);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
@@ -559,7 +574,7 @@ const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_
     const lv_obj_t * parent = obj;
     while(parent) {
         lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
-
+#if LV_STYLE_CACHE_LEVEL >= 1
         if(!list->ignore_cache && list->style_cnt > 0) {
             if(!list->valid_cache) update_style_cache((lv_obj_t *)parent, part, prop  & (~LV_STYLE_STATE_MASK));
             bool def = false;
@@ -579,7 +594,7 @@ const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_
                 break;
             }
         }
-
+#endif
         lv_state_t state = lv_obj_get_state(parent, part);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
 
@@ -748,8 +763,9 @@ void _lv_obj_reset_style_list_no_refr(lv_obj_t * obj, uint8_t part)
 void _lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
+#if LV_STYLE_CACHE_LEVEL >= 1
     invalidate_style_cache(obj, part, prop);
+#endif
 
     /*If a real style refresh is required*/
     bool real_refr = false;
@@ -1145,12 +1161,12 @@ static void trans_anim_ready_cb(lv_anim_t * a)
 
 #endif
 
+#if LV_STYLE_CACHE_LEVEL >= 1
+
 static bool style_prop_is_cacheable(lv_style_property_t prop)
 {
-
     switch(prop) {
         case LV_STYLE_PROP_ALL:
-        case LV_STYLE_BG_GRAD_DIR:
         case LV_STYLE_CLIP_CORNER:
         case LV_STYLE_TEXT_LETTER_SPACE:
         case LV_STYLE_TEXT_LINE_SPACE:
@@ -1228,7 +1244,6 @@ static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
     list->bg_opa_transp    = bg_opa == LV_OPA_TRANSP ? 1 : 0;
     list->bg_opa_cover     = bg_opa == LV_OPA_COVER ? 1 : 0;
 
-    list->bg_grad_dir_none  = lv_obj_get_style_bg_grad_dir(obj, part) == LV_GRAD_DIR_NONE ? 1 : 0;
     list->border_width_zero = lv_obj_get_style_border_width(obj, part) == 0 ? 1 : 0;
     list->border_side_full = lv_obj_get_style_border_side(obj, part) == LV_BORDER_SIDE_FULL ? 1 : 0;
     list->border_post_off = lv_obj_get_style_border_post(obj, part) == 0 ? 1 : 0;
@@ -1250,8 +1265,16 @@ static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
     }
 
     list->pad_all_zero  = 1;
-    if(lv_obj_get_style_pad_top(obj, part) != 0 ||
-       lv_obj_get_style_pad_bottom(obj, part) != 0 ||
+    lv_style_int_t pad_top = lv_obj_get_style_pad_top(obj, part);
+    lv_style_int_t pad_left = lv_obj_get_style_pad_left(obj, part);
+#if LV_STYLE_CACHE_LEVEL >= 2
+    list->pad_top = 0;
+    list->pad_left = 0;
+    if(pad_top > 0 && pad_top <= _LV_STLYE_CAHCE_INT_MAX) list->pad_top = pad_top;
+    if(pad_left > 0 && pad_left <= _LV_STLYE_CAHCE_INT_MAX) list->pad_left = pad_left;
+#endif
+    if(pad_top != 0 ||
+       pad_left != 0 ||
        lv_obj_get_style_pad_left(obj, part) != 0 ||
        lv_obj_get_style_pad_right(obj, part) != 0) {
         list->pad_all_zero  = 0;
@@ -1354,6 +1377,8 @@ static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_proper
         child = lv_obj_get_child(obj, child);
     }
 }
+#endif /*LV_STYLE_CACHE_LEVEL >= 1*/
+
 
 static void fade_anim_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
diff --git a/src/lv_core/lv_style.c b/src/lv_core/lv_style.c
index 5fc116932..5841206b0 100644
--- a/src/lv_core/lv_style.c
+++ b/src/lv_core/lv_style.c
@@ -1070,9 +1070,9 @@ LV_ATTRIBUTE_FAST_MEM static inline int32_t get_property_index(const lv_style_t
 
     stat[prop & 0xFF]++;
 //
-//    if((prop & 0xFF) == LV_STYLE_PAD_TOP) {
+    if((prop & 0xFF) == LV_STYLE_PAD_TOP) {
 //        printf("pad top\n");
-//    }
+    }
 
     uint8_t prop_id;
     while((prop_id = get_style_prop_id(style, i)) != _LV_STYLE_CLOSEING_PROP) {
diff --git a/src/lv_core/lv_style.h b/src/lv_core/lv_style.h
index c992388c0..9d2954569 100644
--- a/src/lv_core/lv_style.h
+++ b/src/lv_core/lv_style.h
@@ -45,6 +45,10 @@ LV_EXPORT_CONST_INT(LV_RADIUS_CIRCLE);
 
 #define LV_STYLE_PROP_ALL 0xFF
 
+#if LV_STYLE_CACHE_LEVEL >= 2
+#define _LV_STLYE_CAHCE_INT_MAX 63
+#endif
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -236,9 +240,12 @@ typedef struct {
     uint32_t has_trans     : 1;
     uint32_t skip_trans    : 1;      /*1: Temporally skip the transition style if any*/
     uint32_t ignore_trans  : 1;      /*1: Mark that this style list shouldn't receive transitions at all*/
+
+#if LV_STYLE_CACHE_LEVEL >= 1
     uint32_t valid_cache   : 1;      /*1: The cache is valid and can be used*/
     uint32_t ignore_cache  : 1;      /*1: Ignore cache while getting value of properties*/
 
+    /*32 properties*/
     uint32_t radius_zero : 1;
     uint32_t opa_scale_cover      : 1;
     uint32_t clip_corner_off       : 1;
@@ -248,7 +255,6 @@ typedef struct {
     uint32_t blend_mode_all_normal : 1;
     uint32_t bg_opa_transp : 1;
     uint32_t bg_opa_cover : 1;
-    uint32_t bg_grad_dir_none : 1;
 
     uint32_t border_width_zero : 1;
     uint32_t border_side_full : 1;
@@ -263,6 +269,13 @@ typedef struct {
     uint32_t text_space_zero : 1;
     uint32_t text_decor_none : 1;
     uint32_t text_font_normal : 1;
+#endif
+
+#if LV_STYLE_CACHE_LEVEL >= 2
+    uint32_t pad_top :6;
+    uint32_t pad_left :6;
+#endif
+
 } lv_style_list_t;
 
 /**********************
diff --git a/src/lv_widgets/lv_label.c b/src/lv_widgets/lv_label.c
index cfb74e16e..8dd5d84e8 100644
--- a/src/lv_widgets/lv_label.c
+++ b/src/lv_widgets/lv_label.c
@@ -1163,7 +1163,7 @@ static lv_res_t lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param
     /* Include the ancient signal function */
     res = ancestor_signal(label, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
     if(sign == LV_SIGNAL_CLEANUP) {

From f002f6a7220bc5a2a5905fe859f4598baa69d009 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 8 Sep 2020 10:08:19 +0200
Subject: [PATCH 28/84] minor grid fix

---
 src/lv_core/lv_obj.c     |  1 -
 src/lv_core/lv_obj_pos.c | 18 ++++++++----------
 2 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 3ce1e7951..43228435b 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -727,7 +727,6 @@ void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f)
     obj->flags &= (~f);
 }
 
-
 /**
  * Set the state (fully overwrite) of an object.
  * If specified in the styles a transition animation will be started
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 247cb108e..b4895ade6 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -62,16 +62,14 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     }
 
     /*If not grid item but has grid position set the position to 0*/
-//    if(!gi) {
-//        if(_GRID_IS_CELL(x)) {
-//            obj->x_set = 0;
-//            x = 0;
-//        }
-//        if(_GRID_IS_CELL(y)) {
-//            obj->y_set = 0;
-//            y = 0;
-//        }
-//    }
+    if(!gi) {
+        if(_GRID_IS_CELL(x)) {
+            x = 0;
+        }
+        if(_GRID_IS_CELL(y)) {
+            y = 0;
+        }
+    }
 
     /*If the object is on a grid item let the grid to position it. */
     if(gi) {

From 40b987dc8184e05a9e91d6e05b34bec30b18f7dd Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 8 Sep 2020 10:51:24 +0200
Subject: [PATCH 29/84] optimize grid recalcualtion on style change

---
 src/lv_core/lv_grid.c     |  64 +++++
 src/lv_core/lv_obj.c      |   4 +-
 src/lv_core/lv_obj.h      |   2 +-
 src/lv_core/lv_obj_draw.c | 570 ++++++++++++++++++++++++++++++++++++++
 src/lv_core/lv_obj_draw.h | 106 +++++++
 5 files changed, 744 insertions(+), 2 deletions(-)
 create mode 100644 src/lv_core/lv_obj_draw.c
 create mode 100644 src/lv_core/lv_obj_draw.h

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index c68a649a3..abcf0b30d 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -12,6 +12,7 @@
 /*********************
  *      DEFINES
  *********************/
+#define LV_OBJX_NAME "lv_obj"
 #define CALC_DSC_BUF_SIZE   8
 
 /**********************
@@ -31,6 +32,7 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint);
+static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 
 /**********************
  *  STATIC VARIABLES
@@ -48,6 +50,50 @@ static bool row_dsc_buf_used;
  *   GLOBAL FUNCTIONS
  **********************/
 
+/**
+ * Set a grid for an object
+ * @param obj pointer to an object
+ * @param grid the grid to set
+ */
+void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->grid = grid;
+    _lv_grid_full_refresh(obj);
+}
+
+/**
+ * Get the grid of an object
+ * @param obj pointer to an object
+ * @return the grid, NULL if no grid
+ */
+const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    return obj->grid;
+}
+
+
+/**
+ * Notify all object if a style is modified
+ * @param grid pointer to a grid. Only the objects with this grid will be notified
+ *               (NULL to notify all objects with any grid)
+ */
+void lv_obj_report_grid_change(const lv_grid_t * grid)
+{
+    lv_disp_t * d = lv_disp_get_next(NULL);
+
+    while(d) {
+        lv_obj_t * i;
+        _LV_LL_READ(d->scr_ll, i) {
+            report_grid_change_core(grid, i);
+        }
+        d = lv_disp_get_next(d);
+    }
+}
+
 /**
  * Calculate the grid cells coordinates
  * @param obj an object that has a grid
@@ -535,3 +581,21 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
 
     if(moved) _lv_obj_move_to(item, x, y, false);
 }
+
+
+/**
+ * Refresh the grid of all children of an object. (Called recursively)
+ * @param grid refresh objects only with this grid.
+ * @param obj pointer to an object
+ */
+static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj)
+{
+    if(obj->grid == grid || (obj->grid && grid == NULL)) _lv_grid_full_refresh(obj);
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child) {
+        report_grid_change_core(grid, child);
+        child = lv_obj_get_child(obj, child);
+    }
+
+}
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 43228435b..68c682e68 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1852,9 +1852,11 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
 
+        if(obj->grid) _lv_grid_full_refresh(obj);
+
         lv_obj_t * child = lv_obj_get_child(obj, NULL);
         while(child) {
-            if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
+            if(!_GRID_IS_CELL(child->x_set) || !_GRID_IS_CELL(child->y_set)) {
                 lv_obj_set_pos(child, child->x_set, child->y_set);
             }
             child = lv_obj_get_child(obj, child);
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 4fff3710b..00a8712e1 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -252,7 +252,7 @@ typedef struct _lv_obj_t {
     lv_obj_user_data_t user_data; /**< Custom user data for object. */
 #endif
 
-    lv_grid_t * grid;
+    const lv_grid_t * grid;
 
 } lv_obj_t;
 
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
new file mode 100644
index 000000000..272496dbb
--- /dev/null
+++ b/src/lv_core/lv_obj_draw.c
@@ -0,0 +1,570 @@
+/**
+ * @file lv_obj_draw.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_obj_draw.h"
+#include "lv_obj.h"
+#include "lv_disp.h"
+#include "lv_indev.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_OBJX_NAME "lv_obj"
+
+#define SCROLLBAR_MIN_SIZE (LV_DPX(10))
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize a rectangle draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_PART_REL` or `LV_SLIDER_PART_KNOB`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If an `*_opa` filed is set to `LV_OPA_TRANSP` the related properties won't be initialized.
+ *                 Should be initialized with `lv_draw_rect_dsc_init(draw_dsc)`.
+ * @note Only the relevant fields will be set.
+ *       E.g. if `border width == 0` the other border properties won't be evaluated.
+ */
+void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t * draw_dsc)
+{
+    draw_dsc->radius = lv_obj_get_style_radius(obj, part);
+
+#if LV_USE_OPA_SCALE
+    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
+    if(opa_scale <= LV_OPA_MIN) {
+        draw_dsc->bg_opa = LV_OPA_TRANSP;
+        draw_dsc->border_opa = LV_OPA_TRANSP;
+        draw_dsc->shadow_opa = LV_OPA_TRANSP;
+        draw_dsc->pattern_opa = LV_OPA_TRANSP;
+        draw_dsc->value_opa = LV_OPA_TRANSP;
+        return;
+    }
+#endif
+
+    if(draw_dsc->bg_opa != LV_OPA_TRANSP) {
+        draw_dsc->bg_opa = lv_obj_get_style_bg_opa(obj, part);
+        if(draw_dsc->bg_opa > LV_OPA_MIN) {
+            draw_dsc->bg_color = lv_obj_get_style_bg_color(obj, part);
+            draw_dsc->bg_grad_dir =  lv_obj_get_style_bg_grad_dir(obj, part);
+            if(draw_dsc->bg_grad_dir != LV_GRAD_DIR_NONE) {
+                draw_dsc->bg_grad_color = lv_obj_get_style_bg_grad_color(obj, part);
+                draw_dsc->bg_main_color_stop =  lv_obj_get_style_bg_main_stop(obj, part);
+                draw_dsc->bg_grad_color_stop =  lv_obj_get_style_bg_grad_stop(obj, part);
+            }
+
+#if LV_USE_BLEND_MODES
+            draw_dsc->bg_blend_mode = lv_obj_get_style_bg_blend_mode(obj, part);
+#endif
+        }
+    }
+
+    draw_dsc->border_width = lv_obj_get_style_border_width(obj, part);
+    if(draw_dsc->border_width) {
+        if(draw_dsc->border_opa != LV_OPA_TRANSP) {
+            draw_dsc->border_opa = lv_obj_get_style_border_opa(obj, part);
+            if(draw_dsc->border_opa > LV_OPA_MIN) {
+                draw_dsc->border_side = lv_obj_get_style_border_side(obj, part);
+                draw_dsc->border_color = lv_obj_get_style_border_color(obj, part);
+            }
+#if LV_USE_BLEND_MODES
+            draw_dsc->border_blend_mode = lv_obj_get_style_border_blend_mode(obj, part);
+#endif
+        }
+    }
+
+#if LV_USE_OUTLINE
+    draw_dsc->outline_width = lv_obj_get_style_outline_width(obj, part);
+    if(draw_dsc->outline_width) {
+        if(draw_dsc->outline_opa != LV_OPA_TRANSP) {
+            draw_dsc->outline_opa = lv_obj_get_style_outline_opa(obj, part);
+            if(draw_dsc->outline_opa > LV_OPA_MIN) {
+                draw_dsc->outline_pad = lv_obj_get_style_outline_pad(obj, part);
+                draw_dsc->outline_color = lv_obj_get_style_outline_color(obj, part);
+            }
+#if LV_USE_BLEND_MODES
+            draw_dsc->outline_blend_mode = lv_obj_get_style_outline_blend_mode(obj, part);
+#endif
+        }
+    }
+#endif
+
+#if LV_USE_PATTERN
+    draw_dsc->pattern_image = lv_obj_get_style_pattern_image(obj, part);
+    if(draw_dsc->pattern_image) {
+        if(draw_dsc->pattern_opa != LV_OPA_TRANSP) {
+            draw_dsc->pattern_opa = lv_obj_get_style_pattern_opa(obj, part);
+            if(draw_dsc->pattern_opa > LV_OPA_MIN) {
+                draw_dsc->pattern_recolor_opa = lv_obj_get_style_pattern_recolor_opa(obj, part);
+                draw_dsc->pattern_repeat = lv_obj_get_style_pattern_repeat(obj, part);
+                if(lv_img_src_get_type(draw_dsc->pattern_image) == LV_IMG_SRC_SYMBOL) {
+                    draw_dsc->pattern_recolor = lv_obj_get_style_pattern_recolor(obj, part);
+                    draw_dsc->pattern_font = lv_obj_get_style_text_font(obj, part);
+                }
+                else if(draw_dsc->pattern_recolor_opa > LV_OPA_MIN) {
+                    draw_dsc->pattern_recolor = lv_obj_get_style_pattern_recolor(obj, part);
+                }
+#if LV_USE_BLEND_MODES
+                draw_dsc->pattern_blend_mode = lv_obj_get_style_pattern_blend_mode(obj, part);
+#endif
+            }
+        }
+    }
+#endif
+
+#if LV_USE_SHADOW
+    draw_dsc->shadow_width = lv_obj_get_style_shadow_width(obj, part);
+    if(draw_dsc->shadow_width) {
+        if(draw_dsc->shadow_opa > LV_OPA_MIN) {
+            draw_dsc->shadow_opa = lv_obj_get_style_shadow_opa(obj, part);
+            if(draw_dsc->shadow_opa > LV_OPA_MIN) {
+                draw_dsc->shadow_ofs_x = lv_obj_get_style_shadow_ofs_x(obj, part);
+                draw_dsc->shadow_ofs_y = lv_obj_get_style_shadow_ofs_y(obj, part);
+                draw_dsc->shadow_spread = lv_obj_get_style_shadow_spread(obj, part);
+                draw_dsc->shadow_color = lv_obj_get_style_shadow_color(obj, part);
+#if LV_USE_BLEND_MODES
+                draw_dsc->shadow_blend_mode = lv_obj_get_style_shadow_blend_mode(obj, part);
+#endif
+            }
+        }
+    }
+#endif
+
+#if LV_USE_VALUE_STR
+    draw_dsc->value_str = lv_obj_get_style_value_str(obj, part);
+    if(draw_dsc->value_str) {
+        if(draw_dsc->value_opa > LV_OPA_MIN) {
+            draw_dsc->value_opa = lv_obj_get_style_value_opa(obj, part);
+            if(draw_dsc->value_opa > LV_OPA_MIN) {
+                draw_dsc->value_ofs_x = lv_obj_get_style_value_ofs_x(obj, part);
+                draw_dsc->value_ofs_y = lv_obj_get_style_value_ofs_y(obj, part);
+                draw_dsc->value_color = lv_obj_get_style_value_color(obj, part);
+                draw_dsc->value_font = lv_obj_get_style_value_font(obj, part);
+                draw_dsc->value_letter_space = lv_obj_get_style_value_letter_space(obj, part);
+                draw_dsc->value_line_space = lv_obj_get_style_value_line_space(obj, part);
+                draw_dsc->value_align = lv_obj_get_style_value_align(obj, part);
+#if LV_USE_BLEND_MODES
+                draw_dsc->value_blend_mode = lv_obj_get_style_value_blend_mode(obj, part);
+#endif
+            }
+        }
+    }
+#endif
+
+#if LV_USE_OPA_SCALE
+    if(opa_scale < LV_OPA_MAX) {
+        draw_dsc->bg_opa = (uint16_t)((uint16_t)draw_dsc->bg_opa * opa_scale) >> 8;
+        draw_dsc->border_opa = (uint16_t)((uint16_t)draw_dsc->border_opa * opa_scale) >> 8;
+        draw_dsc->shadow_opa = (uint16_t)((uint16_t)draw_dsc->shadow_opa * opa_scale) >> 8;
+        draw_dsc->pattern_opa = (uint16_t)((uint16_t)draw_dsc->pattern_opa * opa_scale) >> 8;
+        draw_dsc->value_opa = (uint16_t)((uint16_t)draw_dsc->value_opa * opa_scale) >> 8;
+    }
+#endif
+}
+
+/**
+ * Initialize a label draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_PART_REL` or `LV_SLIDER_PART_KNOB`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_label_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_label_dsc(lv_obj_t * obj, uint8_t part, lv_draw_label_dsc_t * draw_dsc)
+{
+    draw_dsc->opa = lv_obj_get_style_text_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN) return;
+
+#if LV_USE_OPA_SCALE
+    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
+    if(opa_scale < LV_OPA_MAX) {
+        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN) return;
+#endif
+
+    draw_dsc->color = lv_obj_get_style_text_color(obj, part);
+    draw_dsc->letter_space = lv_obj_get_style_text_letter_space(obj, part);
+    draw_dsc->line_space = lv_obj_get_style_text_line_space(obj, part);
+    draw_dsc->decor = lv_obj_get_style_text_decor(obj, part);
+#if LV_USE_BLEND_MODES
+    draw_dsc->blend_mode = lv_obj_get_style_text_blend_mode(obj, part);
+#endif
+
+    draw_dsc->font = lv_obj_get_style_text_font(obj, part);
+
+    if(draw_dsc->sel_start != LV_DRAW_LABEL_NO_TXT_SEL && draw_dsc->sel_end != LV_DRAW_LABEL_NO_TXT_SEL) {
+        draw_dsc->color = lv_obj_get_style_text_sel_color(obj, part);
+    }
+
+#if LV_USE_BIDI
+    draw_dsc->bidi_dir = lv_obj_get_base_dir(obj);
+#endif
+}
+
+/**
+ * Initialize an image draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_IMG_PART_MAIN`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_image_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint8_t part, lv_draw_img_dsc_t * draw_dsc)
+{
+    draw_dsc->opa = lv_obj_get_style_image_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN)  return;
+
+#if LV_USE_OPA_SCALE
+    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
+    if(opa_scale < LV_OPA_MAX) {
+        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN)  return;
+#endif
+
+    draw_dsc->angle = 0;
+    draw_dsc->zoom = LV_IMG_ZOOM_NONE;
+    draw_dsc->pivot.x = lv_area_get_width(&obj->coords) / 2;
+    draw_dsc->pivot.y = lv_area_get_height(&obj->coords) / 2;
+
+    draw_dsc->recolor_opa = lv_obj_get_style_image_recolor_opa(obj, part);
+    if(draw_dsc->recolor_opa > 0) {
+        draw_dsc->recolor = lv_obj_get_style_image_recolor(obj, part);
+    }
+#if LV_USE_BLEND_MODES
+    draw_dsc->blend_mode = lv_obj_get_style_image_blend_mode(obj, part);
+#endif
+}
+
+
+/**
+ * Initialize a line draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_LINE_PART_MAIN`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_line_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t * draw_dsc)
+{
+    draw_dsc->width = lv_obj_get_style_line_width(obj, part);
+    if(draw_dsc->width == 0) return;
+
+    draw_dsc->opa = lv_obj_get_style_line_opa(obj, part);
+    if(draw_dsc->opa <= LV_OPA_MIN)  return;
+
+#if LV_USE_OPA_SCALE
+    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, part);
+    if(opa_scale < LV_OPA_MAX) {
+        draw_dsc->opa = (uint16_t)((uint16_t)draw_dsc->opa * opa_scale) >> 8;
+    }
+    if(draw_dsc->opa <= LV_OPA_MIN)  return;
+#endif
+
+    draw_dsc->color = lv_obj_get_style_line_color(obj, part);
+
+    draw_dsc->dash_width = lv_obj_get_style_line_dash_width(obj, part);
+    if(draw_dsc->dash_width) {
+        draw_dsc->dash_gap = lv_obj_get_style_line_dash_gap(obj, part);
+    }
+
+    draw_dsc->round_start = lv_obj_get_style_line_rounded(obj, part);
+    draw_dsc->round_end = draw_dsc->round_start;
+
+#if LV_USE_BLEND_MODES
+    draw_dsc->blend_mode = lv_obj_get_style_line_blend_mode(obj, part);
+#endif
+}
+
+/**
+ * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
+ * @param obj pointer to an object
+ * @param part part of the object
+ * @return the extra size required around the object
+ */
+lv_coord_t _lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part)
+{
+    lv_coord_t s = 0;
+
+    lv_coord_t sh_width = lv_obj_get_style_shadow_width(obj, part);
+    if(sh_width) {
+        lv_opa_t sh_opa = lv_obj_get_style_shadow_opa(obj, part);
+        if(sh_opa > LV_OPA_MIN) {
+            sh_width = sh_width / 2;    /*THe blur adds only half width*/
+            sh_width++;
+            sh_width += lv_obj_get_style_shadow_spread(obj, part);
+            lv_style_int_t sh_ofs_x = lv_obj_get_style_shadow_ofs_x(obj, part);
+            lv_style_int_t sh_ofs_y = lv_obj_get_style_shadow_ofs_y(obj, part);
+            sh_width += LV_MATH_MAX(LV_MATH_ABS(sh_ofs_x), LV_MATH_ABS(sh_ofs_y));
+            s = LV_MATH_MAX(s, sh_width);
+        }
+    }
+
+    const char * value_str = lv_obj_get_style_value_str(obj, part);
+    if(value_str) {
+        lv_opa_t value_opa = lv_obj_get_style_value_opa(obj, part);
+        if(value_opa > LV_OPA_MIN) {
+            lv_style_int_t letter_space = lv_obj_get_style_value_letter_space(obj, part);
+            lv_style_int_t line_space = lv_obj_get_style_value_letter_space(obj, part);
+            const lv_font_t * font = lv_obj_get_style_value_font(obj, part);
+
+            lv_point_t txt_size;
+            _lv_txt_get_size(&txt_size, value_str, font, letter_space, line_space, LV_COORD_MAX, LV_TXT_FLAG_NONE);
+
+            lv_area_t value_area;
+            value_area.x1 = 0;
+            value_area.y1 = 0;
+            value_area.x2 = txt_size.x - 1;
+            value_area.y2 = txt_size.y - 1;
+
+            lv_style_int_t align = lv_obj_get_style_value_align(obj, part);
+            lv_style_int_t xofs = lv_obj_get_style_value_ofs_x(obj, part);
+            lv_style_int_t yofs = lv_obj_get_style_value_ofs_y(obj, part);
+            lv_point_t p_align;
+            _lv_area_align(&obj->coords, &value_area, align, &p_align);
+
+            value_area.x1 += p_align.x + xofs;
+            value_area.y1 += p_align.y + yofs;
+            value_area.x2 += p_align.x + xofs;
+            value_area.y2 += p_align.y + yofs;
+
+            s = LV_MATH_MAX(s, obj->coords.x1 - value_area.x1);
+            s = LV_MATH_MAX(s, obj->coords.y1 - value_area.y1);
+            s = LV_MATH_MAX(s, value_area.x2 - obj->coords.x2);
+            s = LV_MATH_MAX(s, value_area.y2 - obj->coords.y2);
+        }
+    }
+
+    lv_style_int_t outline_width = lv_obj_get_style_outline_width(obj, part);
+    if(outline_width) {
+        lv_opa_t outline_opa = lv_obj_get_style_outline_opa(obj, part);
+        if(outline_opa > LV_OPA_MIN) {
+            lv_style_int_t outline_pad = lv_obj_get_style_outline_pad(obj, part);
+            s = LV_MATH_MAX(s, outline_pad + outline_width);
+        }
+    }
+
+    lv_coord_t w = lv_obj_get_style_transform_width(obj, part);
+    lv_coord_t h = lv_obj_get_style_transform_height(obj, part);
+    lv_coord_t wh = LV_MATH_MAX(w, h);
+    if(wh > 0) s += wh;
+
+    return s;
+}
+
+/**
+ * Send a 'LV_SIGNAL_REFR_EXT_SIZE' signal to the object to refresh the extended draw area.
+ * The result will be written into `obj->ext_draw_pad`
+ * @param obj pointer to an object
+ */
+void _lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    obj->ext_draw_pad = 0;
+    obj->signal_cb(obj, LV_SIGNAL_REFR_EXT_DRAW_PAD, NULL);
+
+}
+
+/**
+ * Draw scrollbars on an object is required
+ * @param obj pointer to an object
+ * @param clip_area the clip area coming from the design function
+ */
+void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
+{
+    lv_scroll_dir_t sm = lv_obj_get_scroll_mode(obj);
+    if(sm == LV_SCROLL_MODE_OFF) {
+        return;
+    }
+
+    lv_coord_t st = lv_obj_get_scroll_top(obj);
+    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
+    lv_coord_t sl = lv_obj_get_scroll_left(obj);
+    lv_coord_t sr = lv_obj_get_scroll_right(obj);
+
+    /*Return if too small content to scroll*/
+    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sr <= 0) {
+        return;
+    }
+
+    /*If there is no indev scrolling this object but the moe is active return*/
+    lv_indev_t * indev = lv_indev_get_next(NULL);
+    if(sm == LV_SCROLL_MODE_ACTIVE) {
+        bool found = false;
+        while(indev) {
+            if(lv_indev_get_scroll_obj(indev) == obj) {
+                found = true;
+                break;
+            }
+            indev = lv_indev_get_next(indev);
+        }
+        if(!found) {
+            return;
+        }
+    }
+
+    lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t tickness = lv_obj_get_style_scrollbar_tickness(obj, LV_OBJ_PART_MAIN);
+
+    lv_coord_t obj_h = lv_obj_get_height(obj);
+    lv_coord_t obj_w = lv_obj_get_width(obj);
+
+    bool ver_draw = false;
+    if((sm == LV_SCROLL_MODE_ON) ||
+       (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
+       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER)) {
+        ver_draw = true;
+    }
+
+    bool hor_draw = false;
+    if((sm == LV_SCROLL_MODE_ON) ||
+       (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
+       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR)) {
+        hor_draw = true;
+    }
+
+    lv_coord_t ver_reg_space = ver_draw ? tickness + side_space : 0;
+    lv_coord_t hor_req_space = hor_draw ? tickness + side_space : 0;
+    lv_coord_t rem;
+
+    lv_draw_rect_dsc_t draw_dsc;
+    lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
+    if(sb_res != LV_RES_OK) return;
+
+    lv_area_t area;
+    area.y1 = obj->coords.y1;
+    area.y2 = obj->coords.y2;
+    area.x2 = obj->coords.x2 - side_space;
+    area.x1 = area.x2 - tickness;
+
+    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
+    if(ver_draw && _lv_area_is_on(&area, clip_area)) {
+        lv_coord_t content_h = obj_h + st + sb;
+        lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
+        sb_h = LV_MATH_MAX(sb_h, SCROLLBAR_MIN_SIZE);
+        rem = (obj_h - end_space * 2 - hor_req_space) - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
+        if(scroll_h <= 0) {
+            area.y1 = obj->coords.y1 + end_space;
+            area.y2 = obj->coords.y2 - end_space - hor_req_space - 1;
+            area.x2 = obj->coords.x2 - side_space;
+            area.x1 = area.x2 - tickness + 1;
+        } else {
+            lv_coord_t sb_y = (rem * sb) / scroll_h;
+            sb_y = rem - sb_y;
+
+            area.y1 = obj->coords.y1 + sb_y + end_space;
+            area.y2 = area.y1 + sb_h - 1;
+            area.x2 = obj->coords.x2 - side_space;
+            area.x1 = area.x2 - tickness;
+            if(area.y1 < obj->coords.y1 + end_space) {
+                area.y1 = obj->coords.y1 + end_space;
+                if(area.y1 + SCROLLBAR_MIN_SIZE > area.y2) area.y2 = area.y1 + SCROLLBAR_MIN_SIZE;
+            }
+            if(area.y2 > obj->coords.y2 - hor_req_space - end_space) {
+                area.y2 = obj->coords.y2 - hor_req_space - end_space;
+                if(area.y2 - SCROLLBAR_MIN_SIZE < area.y1) area.y1 = area.y2 - SCROLLBAR_MIN_SIZE;
+            }
+        }
+        lv_draw_rect(&area, clip_area, &draw_dsc);
+    }
+
+    area.y2 = obj->coords.y2 - side_space;
+    area.y1 =area.y2 - tickness;
+    area.x1 = obj->coords.x1;
+    area.x2 = obj->coords.x2;
+    /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
+    if(hor_draw && _lv_area_is_on(&area, clip_area)) {
+        lv_coord_t content_w = obj_w + sl + sr;
+        lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
+        sb_w = LV_MATH_MAX(sb_w, SCROLLBAR_MIN_SIZE);
+        rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
+        if(scroll_w <= 0) {
+            area.y2 = obj->coords.y2 - side_space;
+            area.y1 = area.y2 - tickness + 1;
+            area.x1 = obj->coords.x1 + end_space;
+            area.x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
+        } else {
+            lv_coord_t sb_x = (rem * sr) / scroll_w;
+            sb_x = rem - sb_x;
+
+            area.x1 = obj->coords.x1 + sb_x + end_space;
+            area.x2 = area.x1 + sb_w - 1;
+            area.y2 = obj->coords.y2 - side_space;
+            area.y1 = area.y2 - tickness;
+            if(area.x1 < obj->coords.x1 + end_space) {
+                area.x1 = obj->coords.x1 + end_space;
+                if(area.x1 + SCROLLBAR_MIN_SIZE > area.x2) area.x2 = area.x1 + SCROLLBAR_MIN_SIZE;
+            }
+            if(area.x2 > obj->coords.x2 - ver_reg_space - end_space) {
+                area.x2 = obj->coords.x2 - ver_reg_space - end_space;
+                if(area.x2 - SCROLLBAR_MIN_SIZE < area.x1) area.x1 = area.x2 - SCROLLBAR_MIN_SIZE;
+            }
+        }
+        lv_draw_rect(&area, clip_area, &draw_dsc);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the draw descriptor for the scrollbar
+ * @param obj pointer to an object
+ * @param dsc the draw descriptor to initialize
+ * @return LV_RES_OK: the scrollbar is visible; LV_RES_INV: the scrollbar is not visible
+ */
+static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
+{
+    lv_draw_rect_dsc_init(dsc);
+    dsc->bg_opa = lv_obj_get_style_scrollbar_bg_opa(obj, LV_OBJ_PART_MAIN);
+    if(dsc->bg_opa > LV_OPA_MIN) {
+        dsc->bg_color = lv_obj_get_style_scrollbar_bg_color(obj, LV_OBJ_PART_MAIN);
+    }
+
+    dsc->border_opa = lv_obj_get_style_scrollbar_border_opa(obj, LV_OBJ_PART_MAIN);
+    if(dsc->border_opa > LV_OPA_MIN) {
+        dsc->border_width = lv_obj_get_style_scrollbar_border_width(obj, LV_OBJ_PART_MAIN);
+        if(dsc->border_width > 0) {
+            dsc->border_color = lv_obj_get_style_scrollbar_border_color(obj, LV_OBJ_PART_MAIN);
+        } else {
+            dsc->border_opa = LV_OPA_TRANSP;
+        }
+    }
+
+    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP) {
+        dsc->radius = lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
+        return LV_RES_OK;
+    } else {
+        return LV_RES_INV;
+    }
+}
+
diff --git a/src/lv_core/lv_obj_draw.h b/src/lv_core/lv_obj_draw.h
new file mode 100644
index 000000000..3cf7486a9
--- /dev/null
+++ b/src/lv_core/lv_obj_draw.h
@@ -0,0 +1,106 @@
+/**
+ * @file lv_obj_draw.h
+ *
+ */
+
+#ifndef LV_OBJ_DRAW_H
+#define LV_OBJ_DRAW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_draw/lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_obj_t;
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize a rectangle draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_PART_REL` or `LV_SLIDER_PART_KNOB`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If an `*_opa` filed is set to `LV_OPA_TRANSP` the related properties won't be initialized.
+ *                 Should be initialized with `lv_draw_rect_dsc_init(draw_dsc)`.
+ * @note Only the relevant fields will be set.
+ *       E.g. if `border width == 0` the other border properties won't be evaluated.
+ */
+void lv_obj_init_draw_rect_dsc(struct _lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t * draw_dsc);
+
+/**
+ * Initialize a label draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_OBJ_PART_MAIN`, `LV_BTN_PART_REL` or `LV_SLIDER_PART_KNOB`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_label_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_label_dsc(struct _lv_obj_t * obj, uint8_t part, lv_draw_label_dsc_t * draw_dsc);
+
+/**
+ * Initialize an image draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_IMG_PART_MAIN`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_image_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_img_dsc(struct _lv_obj_t * obj, uint8_t part, lv_draw_img_dsc_t * draw_dsc);
+
+/**
+ * Initialize a line draw descriptor from an object's styles in its current state
+ * @param obj pointer to an object
+ * @param type type of style. E.g.  `LV_LINE_PART_MAIN`
+ * @param draw_dsc the descriptor the initialize.
+ *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ *                 Should be initialized with `lv_draw_line_dsc_init(draw_dsc)`.
+ */
+void lv_obj_init_draw_line_dsc(struct _lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t * draw_dsc);
+
+/**
+ * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
+ * @param obj pointer to an object
+ * @param part part of the object
+ * @return the extra size required around the object
+ */
+lv_coord_t _lv_obj_get_draw_rect_ext_pad_size(struct _lv_obj_t * obj, uint8_t part);
+
+/**
+ * Send a 'LV_SIGNAL_REFR_EXT_SIZE' signal to the object to refresh the extended draw area.
+ * The result will be written into `obj->ext_draw_pad`
+ * @param obj pointer to an object
+ */
+void _lv_obj_refresh_ext_draw_pad(struct _lv_obj_t * obj);
+
+/**
+ * Draw scrollbars on an object is required
+ * @param obj pointer to an object
+ * @param clip_area the clip area coming from the design function
+ */
+void _lv_obj_draw_scrollbar(struct _lv_obj_t * obj, const lv_area_t * clip_area);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_OBJ_DRAW_H*/

From dc7c18916ffcb8312a4c949718fa7c78a5dc1ab5 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 8 Sep 2020 15:57:37 +0200
Subject: [PATCH 30/84] grid_calc: handle  w,h,x,y sparately to prepare for gap
 handling

---
 src/lv_core/lv_grid.c      | 170 ++++++++++++++-----------------------
 src/lv_core/lv_grid.h      |  12 ++-
 src/lv_core/lv_obj.c       |   2 +-
 src/lv_core/lv_obj_pos.c   |   4 +-
 src/lv_core/lv_obj_style.c |   2 +
 5 files changed, 75 insertions(+), 115 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index abcf0b30d..07df28622 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -13,7 +13,6 @@
  *      DEFINES
  *********************/
 #define LV_OBJX_NAME "lv_obj"
-#define CALC_DSC_BUF_SIZE   8
 
 /**********************
  *      TYPEDEFS
@@ -37,10 +36,6 @@ static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 /**********************
  *  STATIC VARIABLES
  **********************/
-static lv_coord_t col_dsc_calc_buf[CALC_DSC_BUF_SIZE];
-static lv_coord_t row_dsc_calc_buf[CALC_DSC_BUF_SIZE];
-static bool col_dsc_buf_used;
-static bool row_dsc_buf_used;
 
 /**********************
  *      MACROS
@@ -118,6 +113,9 @@ void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc_out)
         calc_explicit_rows(obj, calc_out);
     }
 
+    calc_out->grid_w = calc_out->x[calc_out->col_num - 1] + calc_out->w[calc_out->col_num - 1] - calc_out->x[0];
+    calc_out->grid_h = calc_out->y[calc_out->row_num - 1] + calc_out->h[calc_out->row_num - 1] - calc_out->y[0];
+
 }
 
 /**
@@ -126,8 +124,10 @@ void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc_out)
  */
 void _lv_grid_calc_free(_lv_grid_calc_t * calc)
 {
-    _lv_mem_buf_release(calc->col_dsc);
-    _lv_mem_buf_release(calc->row_dsc);
+    _lv_mem_buf_release(calc->x);
+    _lv_mem_buf_release(calc->y);
+    _lv_mem_buf_release(calc->w);
+    _lv_mem_buf_release(calc->h);
 }
 
 /**
@@ -226,16 +226,12 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
 
 static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
-    lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->grid;
     uint32_t i;
 
-    lv_coord_t * cols_w;
-    if(!col_dsc_buf_used && grid->col_dsc_len <= CALC_DSC_BUF_SIZE) {
-        cols_w = col_dsc_calc_buf;
-        col_dsc_buf_used = true;
-    } else {
-        cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->col_dsc_len);
-    }
+    calc->col_num = grid->col_dsc_len;
+    calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
+    calc->w = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
     uint32_t col_fr_cnt = 0;
     lv_coord_t grid_w = 0;
@@ -245,7 +241,7 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
         lv_coord_t x = grid->col_dsc[i];
         if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
         else {
-            cols_w[i] = x;
+            calc->w[i] = x;
             grid_w += x;
         }
     }
@@ -256,38 +252,28 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
     for(i = 0; i < grid->col_dsc_len; i++) {
         lv_coord_t x = grid->col_dsc[i];
         if(_GRID_IS_FR(x)) {
-            if(auto_w) cols_w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
+            if(auto_w) calc->w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
             else {
                 lv_coord_t f = _GRID_GET_FR(x);
-                cols_w[i] = (free_w * f) / col_fr_cnt;
+                calc->w[i] = (free_w * f) / col_fr_cnt;
             }
         }
     }
 
-    calc->col_dsc_len = grid->col_dsc_len + 1;
-    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
-
-    calc->col_dsc[0] = 0;
-    for(i = 0; i < grid->col_dsc_len; i++) {
-        calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
+    calc->x[0] = 0;
+    for(i = 0; i < grid->col_dsc_len - 1; i++) {
+        calc->x[i + 1] = calc->x[i] + calc->w[i];
     }
-
-    if(col_dsc_buf_used) col_dsc_buf_used = false ;
-    else _lv_mem_buf_release(cols_w);
 }
 
 static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
-    lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->grid;
     uint32_t i;
 
-    lv_coord_t * rows_h;
-    if(!row_dsc_buf_used && grid->row_dsc_len <= CALC_DSC_BUF_SIZE) {
-        rows_h = row_dsc_calc_buf;
-        row_dsc_buf_used = true;
-    } else {
-        rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->row_dsc_len);
-    }
+    calc->row_num = grid->row_dsc_len;
+    calc->y = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
+    calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
 
     uint32_t row_fr_cnt = 0;
     lv_coord_t grid_h = 0;
@@ -299,7 +285,7 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
         lv_coord_t x = grid->row_dsc[i];
         if(_GRID_IS_FR(x)) row_fr_cnt += _GRID_GET_FR(x);
         else {
-            rows_h[i] = x;
+            calc->h[i] = x;
             grid_h += x;
         }
     }
@@ -309,137 +295,100 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
     for(i = 0; i < grid->row_dsc_len; i++) {
         lv_coord_t x = grid->row_dsc[i];
         if(_GRID_IS_FR(x)) {
-            if(auto_h) rows_h[i] = 0;   /*Fr is considered zero if the obj has auto height*/
+            if(auto_h) calc->h[i] = 0;   /*Fr is considered zero if the obj has auto height*/
             else {
                 lv_coord_t f = _GRID_GET_FR(x);
-                rows_h[i] = (free_h * f) / row_fr_cnt;
+                calc->h[i] = (free_h * f) / row_fr_cnt;
             }
         }
     }
 
-    calc->row_dsc_len = grid->row_dsc_len + 1;
-    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+    calc->y[0] = 0;
 
-    calc->row_dsc[0] = 0;
-
-
-    for(i = 0; i < grid->row_dsc_len; i++) {
-        calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
+    for(i = 0; i < calc->row_num - 1; i++) {
+        calc->y[i + 1] = calc->y[i] + calc->h[i];
     }
-
-    if(row_dsc_buf_used) row_dsc_buf_used = false;
-    else _lv_mem_buf_release(rows_h);
 }
 
 
 static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
-    lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->grid;
 
     uint32_t child_cnt = lv_obj_count_children(cont);
 
-    uint32_t col_cnt = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len) + 1; /*+ grid->row_dsc_len - 1 to round up*/
-    /* If `col_dsc_buf_used`, nested a call of this func. will release `col_dsc_buf_used` because it think it taken it.
-     * So mark that if the buffer was taken in this call*/
-    bool col_dsc_buf_mine = false;
-    /*At worst case all children is gird item prepare place for all of them*/
-    lv_coord_t * cols_w;
-    if(!col_dsc_buf_used && col_cnt <= CALC_DSC_BUF_SIZE) {
-        cols_w = col_dsc_calc_buf;
-        col_dsc_buf_used = true;
-        col_dsc_buf_mine = true;
-    } else {
-        cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * col_cnt);
-    }
+    calc->col_num = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len) + 1; /*+ grid->row_dsc_len - 1 to round up*/
+    calc->w  = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
+    calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
     uint32_t i;
 
     lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
     uint32_t row_i = 0;
     uint32_t col_i = 0;
-    cols_w[0] = 0;
+    calc->w[0] = 0;
     while(child) {
         if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
             lv_coord_t w;
             if(_GRID_GET_CELL_FLAG(child->x_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  &w, NULL);
             else w = lv_obj_get_width(child);
-            cols_w[col_i] = LV_MATH_MAX(cols_w[col_i], w);
+            calc->w[col_i] = LV_MATH_MAX(calc->w[col_i], w);
             row_i++;
             if(row_i == grid->row_dsc_len) {
                 row_i = 0;
                 col_i++;
-                cols_w[col_i] = 0;
+                calc->w[col_i] = 0;
             }
         }
         child = lv_obj_get_child_back(cont, child);
     }
 
 
-    calc->col_dsc_len = col_cnt + 1;
-    calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
+    calc->x[0] = 0;
 
-    calc->col_dsc[0] = 0;
-
-    for(i = 0; i < col_cnt; i++) {
-        calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
+    for(i = 0; i < calc->col_num - 1; i++) {
+        calc->x[i + 1] = calc->x[i] + calc->w[i];
     }
-
-    if(col_dsc_buf_used && col_dsc_buf_mine) col_dsc_buf_used = false;
-    else _lv_mem_buf_release(cols_w);
 }
 
 
 static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
 
-    lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->grid;
     uint32_t child_cnt = lv_obj_count_children(cont);
-    uint32_t row_cnt = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len) + 1; /*+ grid->col_dsc_len - 1 to round up*/
-    bool row_dsc_buf_mine = false;
-    /*At worst case all children is gird item prepare place for all of them*/
-    lv_coord_t * rows_h;
-    if(!row_dsc_buf_used && row_cnt <= CALC_DSC_BUF_SIZE) {
-        rows_h = row_dsc_calc_buf;
-        row_dsc_buf_used = true;
-        row_dsc_buf_mine = true;
-    } else {
-        rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * row_cnt);
-    }
+    calc->row_num  = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len) + 1; /*+ grid->col_dsc_len - 1 to round up*/
+    calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
+    calc->y = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
 
     uint32_t i;
 
     lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
     uint32_t col_i = 0;
     uint32_t row_i = 0;
-    rows_h[0] = 0;
+    calc->h[0] = 0;
     while(child) {
         if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
             lv_coord_t h;
             if(_GRID_GET_CELL_FLAG(child->y_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  NULL, &h);
             else h = lv_obj_get_height(child);
-            rows_h[row_i] = LV_MATH_MAX(rows_h[row_i], h);
+            calc->h[row_i] = LV_MATH_MAX(calc->h[row_i], h);
             col_i++;
             if(col_i == grid->col_dsc_len) {
                 col_i = 0;
                 row_i++;
-                rows_h[row_i] = 0;
+                calc->h[row_i] = 0;
             }
         }
         child = lv_obj_get_child_back(cont, child);
     }
 
 
-    calc->row_dsc_len = row_cnt + 1;
-    calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
+    calc->y[0] = 0;
 
-    calc->row_dsc[0] = 0;
-
-    for(i = 0; i < row_cnt; i++) {
-        calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
+    for(i = 0; i < calc->row_num; i++) {
+        calc->y[i + 1] = calc->y[i] + calc->h[i];
     }
-
-    if(row_dsc_buf_used && row_dsc_buf_mine) row_dsc_buf_used = false;
-    else _lv_mem_buf_release(rows_h);
 }
 
 
@@ -509,8 +458,13 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
         }
     }
 
-    lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
-    lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
+    lv_coord_t col_x1 = calc->x[col_pos];
+    lv_coord_t col_x2 = calc->x[col_pos + col_span - 1] + calc->w[col_pos + col_span - 1];
+    lv_coord_t col_w = col_x2 - col_x1;
+
+    lv_coord_t row_y1 = calc->y[row_pos];
+    lv_coord_t row_y2 = calc->y[row_pos + row_span - 1] + calc->h[col_pos + col_span - 1];
+    lv_coord_t row_h = row_y2 - row_y1;
 
     uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
     uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
@@ -522,35 +476,35 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
 
     switch(x_flag) {
         case LV_GRID_START:
-            x = calc->col_dsc[col_pos];
+            x = calc->x[col_pos];
             break;
         case LV_GRID_STRETCH:
-            x = calc->col_dsc[col_pos];
+            x = calc->x[col_pos];
             w = col_w;
             item->w_set = LV_SIZE_STRETCH;
             break;
         case LV_GRID_CENTER:
-            x = calc->col_dsc[col_pos] + (col_w - w) / 2;
+            x = calc->x[col_pos] + (col_w - w) / 2;
             break;
         case LV_GRID_END:
-            x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
+            x = calc->x[col_pos + 1] - lv_obj_get_width(item);
             break;
     }
 
     switch(y_flag) {
         case LV_GRID_START:
-            y = calc->row_dsc[row_pos];
+            y = calc->y[row_pos];
             break;
         case LV_GRID_STRETCH:
-            y = calc->row_dsc[row_pos];
+            y = calc->y[row_pos];
             item->h_set = LV_SIZE_STRETCH;
             h = row_h;
             break;
         case LV_GRID_CENTER:
-            y = calc->row_dsc[row_pos] + (row_h - h) / 2;
+            y = calc->y[row_pos] + (row_h - h) / 2;
             break;
         case LV_GRID_END:
-            y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
+            y = calc->y[row_pos + 1] - lv_obj_get_height(item);
             break;
     }
 
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 9fef06cdf..be4440f1c 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -97,10 +97,14 @@ typedef struct {
 }lv_grid_t;
 
 typedef struct {
-    lv_coord_t * col_dsc;
-    lv_coord_t * row_dsc;
-    uint32_t col_dsc_len;
-    uint32_t row_dsc_len;
+    lv_coord_t * x;
+    lv_coord_t * y;
+    lv_coord_t * w;
+    lv_coord_t * h;
+    uint32_t col_num;
+    uint32_t row_num;
+    lv_coord_t grid_w;
+    lv_coord_t grid_h;
 }_lv_grid_calc_t;
 
 /**********************
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 68c682e68..bf4392e1f 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1854,6 +1854,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 
         if(obj->grid) _lv_grid_full_refresh(obj);
 
+        /*Reposition non grid objects on by one*/
         lv_obj_t * child = lv_obj_get_child(obj, NULL);
         while(child) {
             if(!_GRID_IS_CELL(child->x_set) || !_GRID_IS_CELL(child->y_set)) {
@@ -1862,7 +1863,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
             child = lv_obj_get_child(obj, child);
         }
 
-
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index b4895ade6..0288ab13d 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -462,8 +462,8 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
     if(obj->grid) {
         _lv_grid_calc_t calc;
         _lv_grid_calc(obj, &calc);
-        grid_w = calc.col_dsc[calc.col_dsc_len - 1] + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-        grid_h = calc.row_dsc[calc.row_dsc_len - 1] + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);;
+        grid_w = calc.grid_w + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+        grid_h = calc.grid_h + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
         _lv_grid_calc_free(&calc);
     }
 
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index 54355189d..7516837e3 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -1218,6 +1218,8 @@ static bool style_prop_is_cacheable(lv_style_property_t prop)
  */
 static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
 {
+    printf("update cache\n");
+
     if(style_prop_is_cacheable(prop) == false) return;
 
     lv_style_list_t * list = _lv_obj_get_style_list(obj, part);

From 97d976f9c2027142817505d9ee2ba053cb035059 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 9 Sep 2020 10:46:49 +0200
Subject: [PATCH 31/84] minor fixes

---
 src/lv_core/lv_grid.c         | 147 ++++++++++++++++++++++------------
 src/lv_core/lv_grid.h         |   7 +-
 src/lv_core/lv_indev.c        |   2 +-
 src/lv_core/lv_indev_scroll.c |  84 ++++++++++---------
 src/lv_core/lv_obj.c          |   2 +-
 src/lv_core/lv_obj.h          |  20 ++---
 6 files changed, 158 insertions(+), 104 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 07df28622..845054be5 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -31,6 +31,7 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint);
+static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array);
 static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 
 /**********************
@@ -91,31 +92,37 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
 
 /**
  * Calculate the grid cells coordinates
- * @param obj an object that has a grid
+ * @param cont an object that has a grid
  * @param calc store the calculated cells sizes here
  * @note `_lv_grid_calc_free(calc_out)` needs to be called when `calc_out` is not needed anymore
  */
-void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc_out)
+void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
 {
-    if(obj->grid == NULL) return;
+    if(cont->grid == NULL) return;
 //    printf("calc: %d, %d\n", obj->grid->col_dsc_len, obj->grid->row_dsc_len);
 
-    if(obj->grid->col_dsc && obj->grid->row_dsc) {
-        calc_explicit_rows(obj, calc_out);
-        calc_explicit_cols(obj, calc_out);
+    if(cont->grid->col_dsc && cont->grid->row_dsc) {
+        calc_explicit_rows(cont, calc_out);
+        calc_explicit_cols(cont, calc_out);
     }
-    else if(obj->grid->col_dsc && !obj->grid->row_dsc) {
-        calc_explicit_cols(obj, calc_out);
-        calc_implicit_rows(obj, calc_out);
+    else if(cont->grid->col_dsc && !cont->grid->row_dsc) {
+        calc_explicit_cols(cont, calc_out);
+        calc_implicit_rows(cont, calc_out);
     }
-    else if(!obj->grid->col_dsc && obj->grid->row_dsc) {
-        calc_implicit_cols(obj, calc_out);
-        calc_explicit_rows(obj, calc_out);
+    else if(!cont->grid->col_dsc && cont->grid->row_dsc) {
+        calc_implicit_cols(cont, calc_out);
+        calc_explicit_rows(cont, calc_out);
     }
 
-    calc_out->grid_w = calc_out->x[calc_out->col_num - 1] + calc_out->w[calc_out->col_num - 1] - calc_out->x[0];
-    calc_out->grid_h = calc_out->y[calc_out->row_num - 1] + calc_out->h[calc_out->row_num - 1] - calc_out->y[0];
+    bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
+    lv_coord_t cont_w = lv_obj_get_width_fit(cont);
+    calc_out->grid_w = grid_place(cont_w, auto_w, cont->grid->col_place, cont->grid->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
 
+    bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
+    lv_coord_t cont_h = lv_obj_get_height_fit(cont);
+    calc_out->grid_h = grid_place(cont_h, auto_h, cont->grid->row_place, cont->grid->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
+
+    LV_ASSERT_MEM_INTEGRITY();
 }
 
 /**
@@ -246,8 +253,8 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
         }
     }
 
-    lv_coord_t free_w = lv_obj_get_width_fit(cont) - grid_w;
-
+    lv_coord_t cont_w = lv_obj_get_width_fit(cont) - grid->col_gap * (grid->col_dsc_len - 1);
+    lv_coord_t free_w = cont_w - grid_w;
 
     for(i = 0; i < grid->col_dsc_len; i++) {
         lv_coord_t x = grid->col_dsc[i];
@@ -259,11 +266,6 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
             }
         }
     }
-
-    calc->x[0] = 0;
-    for(i = 0; i < grid->col_dsc_len - 1; i++) {
-        calc->x[i + 1] = calc->x[i] + calc->w[i];
-    }
 }
 
 static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
@@ -290,7 +292,8 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
         }
     }
 
-    lv_coord_t free_h = lv_obj_get_height_fit(cont) - grid_h;
+    lv_coord_t cont_h = lv_obj_get_height_fit(cont) - grid->row_gap * (grid->row_dsc_len - 1);
+    lv_coord_t free_h = cont_h - grid_h;
 
     for(i = 0; i < grid->row_dsc_len; i++) {
         lv_coord_t x = grid->row_dsc[i];
@@ -302,12 +305,6 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
             }
         }
     }
-
-    calc->y[0] = 0;
-
-    for(i = 0; i < calc->row_num - 1; i++) {
-        calc->y[i + 1] = calc->y[i] + calc->h[i];
-    }
 }
 
 
@@ -317,12 +314,10 @@ static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     uint32_t child_cnt = lv_obj_count_children(cont);
 
-    calc->col_num = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len) + 1; /*+ grid->row_dsc_len - 1 to round up*/
-    calc->w  = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
+    calc->col_num = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len); /*+ grid->row_dsc_len - 1 to round up*/
+    calc->w  = _lv_mem_buf_get(sizeof(lv_coord_t) * (calc->col_num + 1));   /*+1 to allow some limit checks later*/
     calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
-    uint32_t i;
-
     lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
     uint32_t row_i = 0;
     uint32_t col_i = 0;
@@ -342,13 +337,6 @@ static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
         }
         child = lv_obj_get_child_back(cont, child);
     }
-
-
-    calc->x[0] = 0;
-
-    for(i = 0; i < calc->col_num - 1; i++) {
-        calc->x[i + 1] = calc->x[i] + calc->w[i];
-    }
 }
 
 
@@ -357,12 +345,10 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     const lv_grid_t * grid = cont->grid;
     uint32_t child_cnt = lv_obj_count_children(cont);
-    calc->row_num  = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len) + 1; /*+ grid->col_dsc_len - 1 to round up*/
-    calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
+    calc->row_num  = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len); /*+ grid->col_dsc_len - 1 to round up*/
+    calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * (calc->row_num + 1));   /*+1 to allow some limit checks later*/
     calc->y = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
 
-    uint32_t i;
-
     lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
     uint32_t col_i = 0;
     uint32_t row_i = 0;
@@ -382,13 +368,6 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
         }
         child = lv_obj_get_child_back(cont, child);
     }
-
-
-    calc->y[0] = 0;
-
-    for(i = 0; i < calc->row_num; i++) {
-        calc->y[i + 1] = calc->y[i] + calc->h[i];
-    }
 }
 
 
@@ -536,6 +515,74 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
     if(moved) _lv_obj_move_to(item, x, y, false);
 }
 
+/**
+ * Place the grid track according to place methods. It keeps the track sizes but sets their position.
+ * It can process both columns or rows according to the passed parameters.
+ * @param cont_size size of the containers content area (width/height)
+ * @param auto_size true: the container has auto size in the current direction
+ * @param place placeing method
+ * @param gap grid gap
+ * @param track_num number of tracks
+ * @param size_array array with the track sizes
+ * @param pos_array write the positions of the tracks here
+ * @return the total size of the grid
+ */
+static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array)
+{
+    lv_coord_t grid_size = 0;
+    uint32_t i;
+
+    if(auto_size) {
+        pos_array[0] = 0;
+    } else {
+
+        /*With spaced placements gap will be calculated from the remaining space*/
+        if(place == LV_GRID_SPACE_AROUND || place == LV_GRID_SPACE_BETWEEN || place == LV_GRID_SPACE_EVENLY) {
+            gap = 0;
+        }
+
+        /*Get the full grid size with gap*/
+        for(i = 0; i < track_num; i++) {
+            grid_size += size_array[i] + gap;
+        }
+        grid_size -= gap;
+
+        /*Calculate the position of the first item and set gap is necessary*/
+        switch(place) {
+        case LV_GRID_START:
+            pos_array[0] = 0;
+            break;
+        case LV_GRID_CENTER:
+            pos_array[0] = (cont_size - grid_size) / 2;
+            break;
+        case LV_GRID_END:
+            pos_array[0] = cont_size - grid_size;
+            break;
+        case LV_GRID_SPACE_BETWEEN:
+            pos_array[0] = 0;
+            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num - 1);
+            break;
+        case LV_GRID_SPACE_AROUND:
+            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num);
+            pos_array[0] = gap / 2;
+            break;
+        case LV_GRID_SPACE_EVENLY:
+            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num + 1);
+            pos_array[0] = gap;
+            break;
+
+        }
+    }
+
+    /*Set the position of all tracks from the start position, gaps and track sizes*/
+    for(i = 0; i < track_num - 1; i++) {
+        pos_array[i + 1] = pos_array[i] + size_array[i] + gap;
+    }
+
+    /*Return the full size of the grid*/
+    return pos_array[track_num - 1] + size_array[track_num - 1] - pos_array[0];
+}
+
 
 /**
  * Refresh the grid of all children of an object. (Called recursively)
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index be4440f1c..14ac908ba 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -19,8 +19,8 @@ extern "C" {
  *      DEFINES
  *********************/
 
-#define LV_GRID_CENTER              0
-#define LV_GRID_START               1
+#define LV_GRID_START               0
+#define LV_GRID_CENTER              1
 #define LV_GRID_END                 2
 #define LV_GRID_STRETCH             3
 #define LV_GRID_SPACE_EVENLY        4
@@ -93,7 +93,8 @@ typedef struct {
     lv_coord_t col_gap;
     lv_coord_t row_gap;
     lv_grid_flow_t flow;
-    uint8_t place_content;
+    uint8_t col_place;
+    uint8_t row_place;
 }lv_grid_t;
 
 typedef struct {
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 565eb020f..24c5c0d94 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1089,7 +1089,7 @@ static void indev_click_focus(lv_indev_proc_t * proc)
 {
     /*Handle click focus*/
     lv_obj_t * obj_to_focus = _lv_obj_get_focused_obj(indev_obj_act);
-    if(lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_PRESS_LOCK) == false &&
+    if(lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_CLICK_FOCUSABLE) &&
        proc->types.pointer.last_pressed != obj_to_focus) {
 #if LV_USE_GROUP
         lv_group_t * g_act = lv_obj_get_group(indev_obj_act);
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index d8f859203..9c34798d3 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -356,30 +356,33 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
 
     lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
     while(child) {
-        lv_coord_t x_child = 0;
-        lv_coord_t x_parent = 0;
-        switch(obj->snap_align_x) {
-        case LV_SCROLL_SNAP_ALIGN_START:
-            x_child = child->coords.x1;
-            x_parent = obj->coords.x1;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_END:
-            x_child = child->coords.x2;
-            x_parent = obj->coords.x2;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_CENTER:
-            x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
-            x_parent = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
-        }
+        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
+            lv_coord_t x_child = 0;
+            lv_coord_t x_parent = 0;
+            switch(obj->snap_align_x) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                x_child = child->coords.x1;
+                x_parent = obj->coords.x1;
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                x_child = child->coords.x2;
+                x_parent = obj->coords.x2;
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER:
+                x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
+                x_parent = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+            }
 
-        x_child += ofs;
-        if(x_child >= min && x_child <= max) {
-            lv_coord_t x = x_child -  x_parent;
-            if(LV_MATH_ABS(x) < LV_MATH_ABS(dist)) dist = x;
+            x_child += ofs;
+            if(x_child >= min && x_child <= max) {
+                lv_coord_t x = x_child -  x_parent;
+                if(LV_MATH_ABS(x) < LV_MATH_ABS(dist)) dist = x;
+            }
         }
 
         child = lv_obj_get_child_back(obj, child);
     }
+    LV_ASSERT_MEM_INTEGRITY();
 
     return dist == LV_COORD_MAX ? 0: -dist;
 }
@@ -399,35 +402,36 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
 
     lv_coord_t dist = LV_COORD_MAX;
 
-    uint32_t cc = 0;
     lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
     while(child) {
-        cc++;
-        lv_coord_t y_child = 0;
-        lv_coord_t y_parent = 0;
-        switch(obj->snap_align_y) {
-        case LV_SCROLL_SNAP_ALIGN_START:
-            y_child = child->coords.y1;
-            y_parent = obj->coords.y1;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_END:
-            y_child = child->coords.y2;
-            y_parent = obj->coords.y2;
-            break;
-        case LV_SCROLL_SNAP_ALIGN_CENTER:
-            y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
-            y_parent = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
-        }
+        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
+            lv_coord_t y_child = 0;
+            lv_coord_t y_parent = 0;
+            switch(obj->snap_align_y) {
+            case LV_SCROLL_SNAP_ALIGN_START:
+                y_child = child->coords.y1;
+                y_parent = obj->coords.y1;
+                break;
+            case LV_SCROLL_SNAP_ALIGN_END:
+                y_child = child->coords.y2;
+                y_parent = obj->coords.y2;
+                break;
+            case LV_SCROLL_SNAP_ALIGN_CENTER:
+                y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
+                y_parent = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+            }
 
-        y_child += ofs;
-        if(y_child >= min && y_child <= max) {
-            lv_coord_t y = y_child -  y_parent;
-            if(LV_MATH_ABS(y) < LV_MATH_ABS(dist)) dist = y;
+            y_child += ofs;
+            if(y_child >= min && y_child <= max) {
+                lv_coord_t y = y_child -  y_parent;
+                if(LV_MATH_ABS(y) < LV_MATH_ABS(dist)) dist = y;
+            }
         }
 
         child = lv_obj_get_child_back(obj, child);
     }
 
+    LV_ASSERT_MEM_INTEGRITY();
     return dist == LV_COORD_MAX ? 0 : -dist;
 }
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index bf4392e1f..78f400ed3 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -284,7 +284,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     /*Set attributes*/
     new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
     new_obj->scroll_dir  = LV_DIR_ALL;
-    new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
+    new_obj->flags = LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SNAPABLE | LV_OBJ_FLAG_PRESS_LOCK | LV_OBJ_FLAG_CLICK_FOCUSABLE;
     if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
     new_obj->scroll.x = 0;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 00a8712e1..fb655aaa1 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -187,15 +187,17 @@ typedef uint8_t lv_dir_t;
 enum {
     LV_OBJ_FLAG_HIDDEN          = (1 << 0),
     LV_OBJ_FLAG_CLICKABLE       = (1 << 1),
-    LV_OBJ_FLAG_SCROLLABLE      = (1 << 2),
-    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 3),
-    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 4),
-    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 5),
-    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 6),
-    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 7),
-    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 8),
-    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 9),
-    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 10),
+    LV_OBJ_FLAG_CLICK_FOCUSABLE       = (1 << 2),
+    LV_OBJ_FLAG_SCROLLABLE      = (1 << 3),
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 4),
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 5),
+    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 6),
+    LV_OBJ_FLAG_SNAPABLE        = (1 << 7),
+    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 8),
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 9),
+    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 10),
+    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 11),
+    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 12),
 };
 typedef uint16_t lv_obj_flag_t;
 

From 877b30017d2504d97372d48120deb7f00b63f186 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 14 Sep 2020 20:13:43 +0200
Subject: [PATCH 32/84] move some widgets to lv_components repo

---
 lvgl.h                            |   14 -
 src/lv_core/lv_grid.c             |   10 +
 src/lv_core/lv_grid.h             |   37 +-
 src/lv_core/lv_obj.c              |  215 +++--
 src/lv_core/lv_obj.h              |   35 +-
 src/lv_core/lv_obj_scroll.c       |    4 +-
 src/lv_core/lv_obj_style.c        |    9 +-
 src/lv_hal/lv_hal_disp.c          |    6 +-
 src/lv_themes/lv_theme_material.c |    6 -
 src/lv_themes/lv_theme_mono.c     |    8 +-
 src/lv_themes/lv_theme_template.c |    6 -
 src/lv_widgets/lv_btn.c           |  224 +----
 src/lv_widgets/lv_btn.h           |  167 +---
 src/lv_widgets/lv_calendar.c      | 1087 -----------------------
 src/lv_widgets/lv_calendar.h      |  199 -----
 src/lv_widgets/lv_cont.c          |  795 -----------------
 src/lv_widgets/lv_cont.h          |  223 -----
 src/lv_widgets/lv_cpicker.c       | 1039 ----------------------
 src/lv_widgets/lv_cpicker.h       |  229 -----
 src/lv_widgets/lv_keyboard.c      |  479 ----------
 src/lv_widgets/lv_keyboard.h      |  180 ----
 src/lv_widgets/lv_label.c         |   50 +-
 src/lv_widgets/lv_label.h         |    5 +-
 src/lv_widgets/lv_led.c           |  251 ------
 src/lv_widgets/lv_led.h           |   97 --
 src/lv_widgets/lv_linemeter.c     |  634 -------------
 src/lv_widgets/lv_linemeter.h     |  170 ----
 src/lv_widgets/lv_list.c          |  923 -------------------
 src/lv_widgets/lv_list.h          |  311 -------
 src/lv_widgets/lv_msgbox.c        |  606 -------------
 src/lv_widgets/lv_msgbox.h        |  188 ----
 src/lv_widgets/lv_page.c          | 1375 -----------------------------
 src/lv_widgets/lv_page.h          |  427 ---------
 src/lv_widgets/lv_spinbox.c       |  603 -------------
 src/lv_widgets/lv_spinbox.h       |  176 ----
 src/lv_widgets/lv_spinner.c       |  326 -------
 src/lv_widgets/lv_spinner.h       |  180 ----
 src/lv_widgets/lv_tabview.c       | 1033 ----------------------
 src/lv_widgets/lv_tabview.h       |  192 ----
 src/lv_widgets/lv_tileview.c      |  475 ----------
 src/lv_widgets/lv_tileview.h      |  164 ----
 src/lv_widgets/lv_win.c           |  807 -----------------
 src/lv_widgets/lv_win.h           |  300 -------
 43 files changed, 181 insertions(+), 14084 deletions(-)
 delete mode 100644 src/lv_widgets/lv_calendar.c
 delete mode 100644 src/lv_widgets/lv_calendar.h
 delete mode 100644 src/lv_widgets/lv_cont.c
 delete mode 100644 src/lv_widgets/lv_cont.h
 delete mode 100644 src/lv_widgets/lv_cpicker.c
 delete mode 100644 src/lv_widgets/lv_cpicker.h
 delete mode 100644 src/lv_widgets/lv_keyboard.c
 delete mode 100644 src/lv_widgets/lv_keyboard.h
 delete mode 100644 src/lv_widgets/lv_led.c
 delete mode 100644 src/lv_widgets/lv_led.h
 delete mode 100644 src/lv_widgets/lv_linemeter.c
 delete mode 100644 src/lv_widgets/lv_linemeter.h
 delete mode 100644 src/lv_widgets/lv_list.c
 delete mode 100644 src/lv_widgets/lv_list.h
 delete mode 100644 src/lv_widgets/lv_msgbox.c
 delete mode 100644 src/lv_widgets/lv_msgbox.h
 delete mode 100644 src/lv_widgets/lv_page.c
 delete mode 100644 src/lv_widgets/lv_page.h
 delete mode 100644 src/lv_widgets/lv_spinbox.c
 delete mode 100644 src/lv_widgets/lv_spinbox.h
 delete mode 100644 src/lv_widgets/lv_spinner.c
 delete mode 100644 src/lv_widgets/lv_spinner.h
 delete mode 100644 src/lv_widgets/lv_tabview.c
 delete mode 100644 src/lv_widgets/lv_tabview.h
 delete mode 100644 src/lv_widgets/lv_tileview.c
 delete mode 100644 src/lv_widgets/lv_tileview.h
 delete mode 100644 src/lv_widgets/lv_win.c
 delete mode 100644 src/lv_widgets/lv_win.h

diff --git a/lvgl.h b/lvgl.h
index 1ab541ea0..c6521df22 100644
--- a/lvgl.h
+++ b/lvgl.h
@@ -49,34 +49,20 @@ extern "C" {
 #include "src/lv_widgets/lv_img.h"
 #include "src/lv_widgets/lv_label.h"
 #include "src/lv_widgets/lv_line.h"
-#include "src/lv_widgets/lv_page.h"
-#include "src/lv_widgets/lv_cont.h"
-#include "src/lv_widgets/lv_list.h"
 #include "src/lv_widgets/lv_chart.h"
 #include "src/lv_widgets/lv_table.h"
 #include "src/lv_widgets/lv_checkbox.h"
-#include "src/lv_widgets/lv_cpicker.h"
 #include "src/lv_widgets/lv_bar.h"
 #include "src/lv_widgets/lv_slider.h"
-#include "src/lv_widgets/lv_led.h"
 #include "src/lv_widgets/lv_btnmatrix.h"
-#include "src/lv_widgets/lv_keyboard.h"
 #include "src/lv_widgets/lv_dropdown.h"
 #include "src/lv_widgets/lv_roller.h"
 #include "src/lv_widgets/lv_textarea.h"
 #include "src/lv_widgets/lv_canvas.h"
-#include "src/lv_widgets/lv_win.h"
-#include "src/lv_widgets/lv_tabview.h"
-#include "src/lv_widgets/lv_tileview.h"
-#include "src/lv_widgets/lv_msgbox.h"
 #include "src/lv_widgets/lv_objmask.h"
 #include "src/lv_widgets/lv_gauge.h"
-#include "src/lv_widgets/lv_linemeter.h"
 #include "src/lv_widgets/lv_switch.h"
 #include "src/lv_widgets/lv_arc.h"
-#include "src/lv_widgets/lv_spinner.h"
-#include "src/lv_widgets/lv_calendar.h"
-#include "src/lv_widgets/lv_spinbox.h"
 
 #include "src/lv_draw/lv_img_cache.h"
 
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 845054be5..b7aadcfce 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -37,6 +37,12 @@ static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 /**********************
  *  STATIC VARIABLES
  **********************/
+static const lv_coord_t lv_grid_1_dsc[1] = {LV_GRID_FR(1)};
+const lv_grid_t lv_grid_center = {
+        .col_dsc = lv_grid_1_dsc,
+        .col_dsc_len = 1,
+        .col_place = LV_GRID_CENTER,
+        .row_place = LV_GRID_CENTER};
 
 /**********************
  *      MACROS
@@ -99,6 +105,10 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
 void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
 {
     if(cont->grid == NULL) return;
+    if(lv_obj_get_child(cont, NULL) == NULL) {
+        _lv_memset_00(calc_out, sizeof(_lv_grid_calc_t));
+        return;
+    }
 //    printf("calc: %d, %d\n", obj->grid->col_dsc_len, obj->grid->row_dsc_len);
 
     if(cont->grid->col_dsc && cont->grid->row_dsc) {
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 14ac908ba..d2cf08c3b 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -77,14 +77,6 @@ extern "C" {
 struct _lv_obj_t;
 typedef struct _lv_obj_t lv_obj_t;
 
-/**
- * Describe how to flow LV_GRID_POS_AUTO elements
- */
-typedef enum {
-    LV_GRID_FLOW_COLUMN, /**Fill each column and add now columns if required*/
-    LV_GRID_FLOW_ROW,    /**Fill each row and add now rows if required*/
-}lv_grid_flow_t;
-
 typedef struct {
     const lv_coord_t * col_dsc;
     const lv_coord_t * row_dsc;
@@ -92,7 +84,6 @@ typedef struct {
     uint8_t row_dsc_len;
     lv_coord_t col_gap;
     lv_coord_t row_gap;
-    lv_grid_flow_t flow;
     uint8_t col_place;
     uint8_t row_place;
 }lv_grid_t;
@@ -118,6 +109,28 @@ void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv
 
 void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
 
+/**
+ * Set a grid for an object
+ * @param obj pointer to an object
+ * @param grid the grid to set
+ */
+void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid);
+
+/**
+ * Get the grid of an object
+ * @param obj pointer to an object
+ * @return the grid, NULL if no grid
+ */
+const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid);
+
+
+/**
+ * Notify all object if a style is modified
+ * @param grid pointer to a grid. Only the objects with this grid will be notified
+ *               (NULL to notify all objects with any grid)
+ */
+void lv_obj_report_grid_change(const lv_grid_t * grid);
+
 void _lv_grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc);
 
 void _lv_grid_calc_free(_lv_grid_calc_t * calc);
@@ -132,6 +145,12 @@ void lv_grid_item_refr_pos(lv_obj_t * item);
 
 bool _lv_obj_is_grid_item(lv_obj_t * obj);
 
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+extern const lv_grid_t lv_grid_center;
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index d440179e6..0b0f40944 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -180,10 +180,9 @@ void lv_deinit(void)
  * Create a basic object
  * @param parent pointer to a parent object.
  *                  If NULL then a screen will be created
- * @param copy pointer to a base object, if not NULL then the new object will be copied from it
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
+lv_obj_t * lv_obj_create(lv_obj_t * parent)
 {
     lv_obj_t * new_obj = NULL;
 
@@ -277,7 +276,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
 #if LV_USE_GROUP
     new_obj->group_p = NULL;
-
 #endif
 
     /*Set attributes*/
@@ -292,49 +290,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->ext_attr = NULL;
 
     lv_style_list_init(&new_obj->style_list);
-    if(copy == NULL) {
-        if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
-        else  lv_theme_apply(new_obj, LV_THEME_SCR);
-    }
-    else {
-        lv_style_list_copy(&new_obj->style_list, &copy->style_list);
-    }
-    /*Copy the attributes if required*/
-    if(copy != NULL) {
-        lv_area_copy(&new_obj->coords, &copy->coords);
-        new_obj->ext_draw_pad = copy->ext_draw_pad;
-
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-        lv_area_copy(&new_obj->ext_click_pad, &copy->ext_click_pad);
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-        new_obj->ext_click_pad = copy->ext_click_pad;
-#endif
-
-        /*Set user data*/
-#if LV_USE_USER_DATA
-        _lv_memcpy(&new_obj->user_data, &copy->user_data, sizeof(lv_obj_user_data_t));
-#endif
-
-        /*Only copy the `event_cb`. `signal_cb` and `design_cb` will be copied in the derived
-         * object type (e.g. `lv_btn`)*/
-        new_obj->event_cb = copy->event_cb;
-
-        /*Copy attributes*/
-        new_obj->flags        = copy->flags;
-        new_obj->scroll_mode  = copy->scroll_mode;
-
-#if LV_USE_GROUP
-        /*Add to the same group*/
-        if(copy->group_p != NULL) {
-            lv_group_add_obj(copy->group_p, new_obj);
-        }
-#endif
-
-        /*Set the same coordinates for non screen objects*/
-        if(lv_obj_get_parent(copy) != NULL && parent != NULL) {
-            lv_obj_set_pos(new_obj, lv_obj_get_x(copy), lv_obj_get_y(copy));
-        }
-    }
+    if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
+    else  lv_theme_apply(new_obj, LV_THEME_SCR);
 
     lv_obj_set_pos(new_obj, 0, 0);
 
@@ -1298,18 +1255,7 @@ lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(part < _LV_OBJ_PART_REAL_LAST) return ((lv_obj_t *)obj)->state;
-
-    /*If a real part is asked, then use the object's signal to get its state.
-     * A real object can be in different state then the main part
-     * and only the object itself knows who to get it's state. */
-    lv_get_state_info_t info;
-    info.part = part;
-    info.result = LV_STATE_DEFAULT;
-    lv_signal_send((lv_obj_t *)obj, LV_SIGNAL_GET_STATE_DSC, &info);
-
-    return info.result;
-
+    return ((lv_obj_t *)obj)->state;
 }
 
 /**
@@ -1808,75 +1754,59 @@ static void base_dir_refr_children(lv_obj_t * obj)
  */
 static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 {
+    lv_res_t res = LV_RES_OK;
+
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         if(info->part == LV_OBJ_PART_MAIN) info->result = &obj->style_list;
         else info->result = NULL;
         return LV_RES_OK;
     }
-    else if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_res_t res = LV_RES_OK;
-
-    if(sign == LV_SIGNAL_COORD_CHG) {
-        if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
-           (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
-        {
-            _lv_grid_full_refresh(obj);
-        }
-    }
-    else if(sign == LV_SIGNAL_CHILD_CHG) {
-        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
-            lv_obj_set_size(obj, obj->w_set, obj->h_set);
-        }
-
-        if(obj->grid) {
-            lv_obj_t * child = param;
-            if(child) {
-                if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
-            } else {
-                _lv_grid_full_refresh(obj);
-            }
-        }
-    }
-    else if(sign == LV_SIGNAL_SCROLL) {
-        res = lv_event_send(obj, LV_EVENT_SCROLLED, NULL);
-        if(res != LV_RES_OK) return res;
-    }
-    else if(sign == LV_SIGNAL_SCROLL_END) {
-        if(lv_obj_get_scroll_mode(obj) == LV_SCROLL_MODE_ACTIVE) {
-            lv_obj_invalidate(obj);
-        }
-
-    }
-    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        lv_coord_t d = 0;//_lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
-        obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
-
-        if(obj->grid) _lv_grid_full_refresh(obj);
-
-        /*Reposition non grid objects on by one*/
-        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-        while(child) {
-            if(!_GRID_IS_CELL(child->x_set) || !_GRID_IS_CELL(child->y_set)) {
-                lv_obj_set_pos(child, child->x_set, child->y_set);
-            }
-            child = lv_obj_get_child(obj, child);
-        }
-
-        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
-            lv_obj_set_size(obj, obj->w_set, obj->h_set);
-        }
-        _lv_obj_refresh_ext_draw_pad(obj);
+    else if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
     else if(sign == LV_SIGNAL_PRESSED) {
         lv_obj_add_state(obj, LV_STATE_PRESSED);
     }
-    else if(sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST) {
+    else if(sign == LV_SIGNAL_RELEASED) {
         lv_obj_clear_state(obj, LV_STATE_PRESSED);
+
+        /*Go the checked state if enabled*/
+        if(lv_indev_get_scroll_obj(param) == NULL && lv_obj_has_flag(obj, LV_OBJ_FLAG_CHECKABLE)) {
+            uint32_t toggled = 0;
+            if(!(lv_obj_get_state(obj, LV_OBJ_PART_MAIN) & LV_STATE_CHECKED)) {
+                lv_obj_add_state(obj, LV_STATE_CHECKED);
+                toggled = 0;
+            }
+            else {
+                lv_obj_clear_state(obj, LV_STATE_CHECKED);
+                toggled = 1;
+            }
+
+            res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, &toggled);
+            if(res != LV_RES_OK) return res;
+        }
+    }
+    else if(sign == LV_SIGNAL_PRESS_LOST) {
+        lv_obj_clear_state(obj, LV_STATE_PRESSED);
+    }
+    else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
+        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_CHECKABLE)) {
+            uint32_t state = 0;
+            char c = *((char *)param);
+            if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
+                lv_obj_set_state(obj, LV_STATE_CHECKED);
+                state = 1;
+            }
+            else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
+                lv_obj_clear_state(obj, LV_STATE_CHECKED);
+                state = 0;
+            }
+            res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, &state);
+            if(res != LV_RES_OK) return res;
+        }
+#endif
     }
     else if(sign == LV_SIGNAL_FOCUS) {
         bool editing = false;
@@ -1908,6 +1838,59 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
+    else if(sign == LV_SIGNAL_COORD_CHG) {
+        if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
+           (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
+        {
+            _lv_grid_full_refresh(obj);
+        }
+    }
+    else if(sign == LV_SIGNAL_CHILD_CHG) {
+        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
+            lv_obj_set_size(obj, obj->w_set, obj->h_set);
+        }
+
+        if(obj->grid) {
+            lv_obj_t * child = param;
+            if(child) {
+                if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
+            } else {
+                _lv_grid_full_refresh(obj);
+            }
+        }
+    }
+    else if(sign == LV_SIGNAL_SCROLL) {
+        res = lv_event_send(obj, LV_EVENT_SCROLLED, NULL);
+        if(res != LV_RES_OK) return res;
+    }
+    else if(sign == LV_SIGNAL_SCROLL_END) {
+        if(lv_obj_get_scroll_mode(obj) == LV_SCROLL_MODE_ACTIVE) {
+            lv_obj_invalidate(obj);
+        }
+    }
+    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
+        lv_coord_t d = _lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
+        obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
+    }
+    else if(sign == LV_SIGNAL_STYLE_CHG) {
+        if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
+
+        if(obj->grid) _lv_grid_full_refresh(obj);
+
+        /*Reposition non grid objects on by one*/
+        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+        while(child) {
+            if(!_GRID_IS_CELL(child->x_set) || !_GRID_IS_CELL(child->y_set)) {
+                lv_obj_set_pos(child, child->x_set, child->y_set);
+            }
+            child = lv_obj_get_child(obj, child);
+        }
+
+        if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
+            lv_obj_set_size(obj, obj->w_set, obj->h_set);
+        }
+        _lv_obj_refresh_ext_draw_pad(obj);
+    }
     else if(sign == LV_SIGNAL_CLEANUP) {
         _lv_obj_reset_style_list_no_refr(obj, LV_OBJ_PART_MAIN);
     }
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index fb655aaa1..3f5477379 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -130,7 +130,6 @@ enum {
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
     LV_SIGNAL_GET_TYPE,          /**< LVGL needs to retrieve the object's type */
     LV_SIGNAL_GET_STYLE,         /**<Get the style of an object*/
-    LV_SIGNAL_GET_STATE_DSC,     /**<Get the state of the object*/
 
     /*Input device related*/
     LV_SIGNAL_HIT_TEST,          /**< Advanced hit-testing */
@@ -187,17 +186,18 @@ typedef uint8_t lv_dir_t;
 enum {
     LV_OBJ_FLAG_HIDDEN          = (1 << 0),
     LV_OBJ_FLAG_CLICKABLE       = (1 << 1),
-    LV_OBJ_FLAG_CLICK_FOCUSABLE       = (1 << 2),
-    LV_OBJ_FLAG_SCROLLABLE      = (1 << 3),
-    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 4),
-    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 5),
-    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 6),
-    LV_OBJ_FLAG_SNAPABLE        = (1 << 7),
-    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 8),
-    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 9),
-    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 10),
-    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 11),
-    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 12),
+    LV_OBJ_FLAG_CLICK_FOCUSABLE = (1 << 2),
+    LV_OBJ_FLAG_CHECKABLE       = (1 << 3),
+    LV_OBJ_FLAG_SCROLLABLE      = (1 << 4),
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 5),
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 6),
+    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 7),
+    LV_OBJ_FLAG_SNAPABLE        = (1 << 8),
+    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 9),
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 10),
+    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 11),
+    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 12),
+    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 13),
 };
 typedef uint16_t lv_obj_flag_t;
 
@@ -260,8 +260,7 @@ typedef struct _lv_obj_t {
 
 enum {
     LV_OBJ_PART_MAIN,
-    _LV_OBJ_PART_VIRTUAL_LAST = _LV_OBJ_PART_VIRTUAL_FIRST,
-    _LV_OBJ_PART_REAL_LAST =    _LV_OBJ_PART_REAL_FIRST,
+    _LV_OBJ_PART_SPACIAL_START =   0x80,
     LV_OBJ_PART_ALL = 0xFF,
 };
 
@@ -283,11 +282,6 @@ typedef struct {
     lv_style_list_t * result;
 } lv_get_style_info_t;
 
-typedef struct {
-    uint8_t part;
-    lv_state_t result;
-} lv_get_state_info_t;
-
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -314,10 +308,9 @@ void lv_deinit(void);
  * Create a basic object
  * @param parent pointer to a parent object.
  *                  If NULL then a screen will be created
- * @param copy pointer to a base object, if not NULL then the new object will be copied from it
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy);
+lv_obj_t * lv_obj_create(lv_obj_t * parent);
 
 /**
  * Delete 'obj' and all of its children
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 83ce66cce..db1b1df7b 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -193,7 +193,7 @@ lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
         child = lv_obj_get_child(obj, child);
     }
 
-    return y2 - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+    return y2 - (obj->coords.y2 - lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN));
 }
 
 /**
@@ -229,7 +229,7 @@ lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
         child = lv_obj_get_child(obj, child);
     }
 
-    return x2 - obj->coords.x2  + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    return x2 - (obj->coords.x2 - lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN));
 }
 
 /**********************
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index ae50d2545..bc4d69bff 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -1058,7 +1058,7 @@ _lv_style_state_cmp_t _lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t sta
 static void report_style_change_core(void * style, lv_obj_t * obj)
 {
     uint8_t part;
-    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
+    for(part = 0; part < _LV_OBJ_PART_SPACIAL_START; part++) {
         lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
         if(list == NULL) break;
 
@@ -1288,6 +1288,7 @@ static _lv_style_state_cmp_t style_snapshot_compare(style_snapshot_t * shot1, st
     if(shot1->transform_zoom != shot2->transform_zoom) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->rect.outline_width != shot2->rect.outline_width) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->rect.outline_pad != shot2->rect.outline_pad) return _LV_STYLE_STATE_CMP_DIFF;
+    if(shot1->rect.outline_opa != shot2->rect.outline_opa) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->rect.value_font != shot2->rect.value_font) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->rect.value_align != shot2->rect.value_align) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->rect.value_font != shot2->rect.value_font) return _LV_STYLE_STATE_CMP_DIFF;
@@ -1358,10 +1359,6 @@ static bool style_prop_is_cacheable(lv_style_property_t prop)
  */
 static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
 {
-    static uint32_t cnt = 0;
-    cnt++;
-    printf("update cache: %d\n", cnt);
-
     if(style_prop_is_cacheable(prop) == false) return;
 
     lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
@@ -1458,7 +1455,7 @@ static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
 static void update_style_cache_children(lv_obj_t * obj)
 {
     uint8_t part;
-    for(part = 0; part != _LV_OBJ_PART_REAL_LAST; part++) {
+    for(part = 0; part < _LV_OBJ_PART_SPACIAL_START; part++) {
         lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
         if(list == NULL) break;
 
diff --git a/src/lv_hal/lv_hal_disp.c b/src/lv_hal/lv_hal_disp.c
index 3e7a33c67..fac9f1a0b 100644
--- a/src/lv_hal/lv_hal_disp.c
+++ b/src/lv_hal/lv_hal_disp.c
@@ -153,9 +153,9 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
 #endif
 
     disp->prev_scr  = NULL;
-    disp->act_scr   = lv_obj_create(NULL, NULL); /*Create a default screen on the display*/
-    disp->top_layer = lv_obj_create(NULL, NULL); /*Create top layer on the display*/
-    disp->sys_layer = lv_obj_create(NULL, NULL); /*Create sys layer on the display*/
+    disp->act_scr   = lv_obj_create(NULL); /*Create a default screen on the display*/
+    disp->top_layer = lv_obj_create(NULL); /*Create top layer on the display*/
+    disp->sys_layer = lv_obj_create(NULL); /*Create sys layer on the display*/
     lv_obj_reset_style_list(disp->top_layer, LV_OBJ_PART_MAIN);
     lv_obj_reset_style_list(disp->sys_layer, LV_OBJ_PART_MAIN);
     lv_obj_clear_flag(disp->top_layer, LV_OBJ_FLAG_CLICKABLE);
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 5116e85e8..09e4ba037 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -985,12 +985,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
-#if LV_USE_CONT
-        case LV_THEME_CONT:
-            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
-            _lv_style_list_add_style(list, &styles->bg);
-            break;
-#endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index 8a251cc12..42e5b0ed5 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -584,14 +584,8 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
-#if LV_USE_CONT
-        case LV_THEME_CONT:
-            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
-            _lv_style_list_add_style(list, &styles->bg);
-            break;
-#endif
 
-#if LV_USE_BTN
+            #if LV_USE_BTN
         case LV_THEME_BTN:
             list = _lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index 6777d2846..63bccb2c5 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -428,12 +428,6 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
-#if LV_USE_CONT
-        case LV_THEME_CONT:
-            list = _lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
-            _lv_style_list_add_style(list, &styles->bg);
-            break;
-#endif
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
diff --git a/src/lv_widgets/lv_btn.c b/src/lv_widgets/lv_btn.c
index 87a467c66..1003d84b1 100644
--- a/src/lv_widgets/lv_btn.c
+++ b/src/lv_widgets/lv_btn.c
@@ -23,8 +23,6 @@
  *      DEFINES
  *********************/
 #define LV_OBJX_NAME "lv_btn"
-#define LV_BTN_INK_VALUE_MAX 256
-#define LV_BTN_INK_VALUE_MAX_SHIFT 8
 
 /**********************
  *      TYPEDEFS
@@ -33,14 +31,12 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static lv_design_res_t lv_btn_design(lv_obj_t * btn, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
 
 /**********************
  *      MACROS
@@ -52,56 +48,30 @@ static lv_design_cb_t ancestor_design;
 
 /**
  * Create a button object
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new button
  * @return pointer to the created button
  */
-lv_obj_t * lv_btn_create(lv_obj_t * par, const lv_obj_t * copy)
+lv_obj_t * lv_btn_create(lv_obj_t * parent)
 {
     LV_LOG_TRACE("button create started");
 
     lv_obj_t * btn;
 
-    btn = lv_cont_create(par, copy);
+    btn = lv_obj_create(parent);
     LV_ASSERT_MEM(btn);
     if(btn == NULL) return NULL;
 
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(btn);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(btn);
-
-    /*Allocate the extended data*/
-    lv_btn_ext_t * ext = lv_obj_allocate_ext_attr(btn, sizeof(lv_btn_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(btn);
-        return NULL;
-    }
-
-    ext->checkable = 0;
 
     lv_obj_set_signal_cb(btn, lv_btn_signal);
-    lv_obj_set_design_cb(btn, lv_btn_design);
 
-    /*If no copy do the basic initialization*/
-    if(copy == NULL) {
-        /*Set layout if the button is not a screen*/
-        if(par) {
-            lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
-            lv_btn_set_layout(btn, LV_LAYOUT_CENTER);
-        }
-
-        lv_obj_set_click(btn, true); /*Be sure the button is clickable*/
-
-        lv_theme_apply(btn, LV_THEME_BTN);
+    /*Set layout if the button is not a screen*/
+    if(parent) {
+        lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
+        lv_obj_set_grid(btn, &lv_grid_center);
     }
-    /*Copy 'copy'*/
-    else {
-        lv_btn_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->checkable             = copy_ext->checkable;
 
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(btn, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
+    lv_theme_apply(btn, LV_THEME_BTN);
 
     LV_LOG_INFO("button created");
 
@@ -112,146 +82,14 @@ lv_obj_t * lv_btn_create(lv_obj_t * par, const lv_obj_t * copy)
  * Setter functions
  *====================*/
 
-/**
- * Enable the toggled states
- * @param btn pointer to a button object
- * @param tgl true: enable toggled states, false: disable
- */
-void lv_btn_set_checkable(lv_obj_t * btn, bool tgl)
-{
-    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
-
-    lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
-
-    ext->checkable = tgl != false ? 1 : 0;
-}
-
-/**
- * Set the state of the button
- * @param btn pointer to a button object
- * @param state the new state of the button (from lv_btn_state_t enum)
- */
-void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state)
-{
-    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
-
-    switch(state) {
-        case LV_BTN_STATE_RELEASED:
-            lv_obj_clear_state(btn, LV_STATE_PRESSED | LV_STATE_CHECKED | LV_STATE_DISABLED);
-            break;
-        case LV_BTN_STATE_PRESSED:
-            lv_obj_clear_state(btn, LV_STATE_CHECKED | LV_STATE_DISABLED);
-            lv_obj_add_state(btn, LV_STATE_PRESSED);
-            break;
-        case LV_BTN_STATE_CHECKED_RELEASED:
-            lv_obj_add_state(btn, LV_STATE_CHECKED);
-            lv_obj_clear_state(btn, LV_STATE_PRESSED | LV_STATE_DISABLED);
-            break;
-        case LV_BTN_STATE_CHECKED_PRESSED:
-            lv_obj_add_state(btn, LV_STATE_PRESSED | LV_STATE_CHECKED);
-            lv_obj_clear_state(btn, LV_STATE_DISABLED);
-            break;
-        case LV_BTN_STATE_DISABLED:
-            lv_obj_clear_state(btn, LV_STATE_PRESSED | LV_STATE_CHECKED);
-            lv_obj_add_state(btn, LV_STATE_DISABLED);
-            break;
-        case LV_BTN_STATE_CHECKED_DISABLED:
-            lv_obj_clear_state(btn, LV_STATE_PRESSED);
-            lv_obj_add_state(btn, LV_STATE_DISABLED | LV_STATE_CHECKED);
-            break;
-    }
-}
-
-/**
- * Toggle the state of the button (ON->OFF, OFF->ON)
- * @param btn pointer to a button object
- */
-void lv_btn_toggle(lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
-
-    if(lv_obj_get_state(btn, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
-        lv_obj_clear_state(btn, LV_STATE_CHECKED);
-    }
-    else {
-        lv_obj_add_state(btn, LV_STATE_CHECKED);
-    }
-}
-
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the current state of the button
- * @param btn pointer to a button object
- * @return the state of the button (from lv_btn_state_t enum).
- * If the button is in disabled state `LV_BTN_STATE_DISABLED` will be ORed to the other button states.
- */
-lv_btn_state_t lv_btn_get_state(const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
-
-    lv_state_t obj_state = lv_obj_get_state(btn, LV_BTN_PART_MAIN);
-
-    if(obj_state & LV_STATE_DISABLED) {
-        if(obj_state & LV_STATE_CHECKED) return LV_BTN_STATE_CHECKED_DISABLED;
-        else return LV_BTN_STATE_DISABLED;
-    }
-
-    if(obj_state & LV_STATE_CHECKED) {
-        if(obj_state & LV_STATE_PRESSED) return LV_BTN_STATE_CHECKED_PRESSED;
-        else return LV_BTN_STATE_CHECKED_RELEASED;
-    }
-    else {
-        if(obj_state & LV_STATE_PRESSED) return LV_BTN_STATE_PRESSED;
-        else return LV_BTN_STATE_RELEASED;
-    }
-}
-
-/**
- * Get the toggle enable attribute of the button
- * @param btn pointer to a button object
- * @return true: toggle enabled, false: disabled
- */
-bool lv_btn_get_checkable(const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
-
-    lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
-
-    return ext->checkable != 0 ? true : false;
-}
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
 
-/**
- * Handle the drawing related tasks of the drop down lists
- * @param btn pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_btn_design(lv_obj_t * btn, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_design(btn, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_design(btn, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design(btn, clip_area, mode);
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
 /**
  * Signal function of the button
  * @param btn pointer to a button object
@@ -266,51 +104,9 @@ static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(btn, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
-    bool tgl           = lv_btn_get_checkable(btn);
-
-    if(sign == LV_SIGNAL_RELEASED) {
-        /*If not dragged and it was not long press action then
-         *change state and run the action*/
-        if(lv_indev_get_scroll_dir(param) == LV_SCROLL_DIR_NONE && tgl) {
-            uint32_t toggled = 0;
-            if(lv_obj_get_state(btn, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
-                lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
-                toggled = 0;
-            }
-            else {
-                lv_btn_set_state(btn, LV_BTN_STATE_CHECKED_RELEASED);
-                toggled = 1;
-            }
-
-            res = lv_event_send(btn, LV_EVENT_VALUE_CHANGED, &toggled);
-            if(res != LV_RES_OK) return res;
-        }
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        char c = *((char *)param);
-        if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
-            if(lv_btn_get_checkable(btn)) {
-                lv_btn_set_state(btn, LV_BTN_STATE_CHECKED_RELEASED);
-
-                uint32_t state = 1;
-                res            = lv_event_send(btn, LV_EVENT_VALUE_CHANGED, &state);
-                if(res != LV_RES_OK) return res;
-            }
-
-        }
-        else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
-            if(lv_btn_get_checkable(btn)) {
-                lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
-
-                uint32_t state = 0;
-                res            = lv_event_send(btn, LV_EVENT_VALUE_CHANGED, &state);
-                if(res != LV_RES_OK) return res;
-            }
-        }
-#endif
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
 
     return res;
diff --git a/src/lv_widgets/lv_btn.h b/src/lv_widgets/lv_btn.h
index 34f72f636..721d2b5a1 100644
--- a/src/lv_widgets/lv_btn.h
+++ b/src/lv_widgets/lv_btn.h
@@ -17,12 +17,6 @@ extern "C" {
 
 #if LV_USE_BTN != 0
 
-/*Testing of dependencies*/
-#if LV_USE_CONT == 0
-#error "lv_btn: lv_cont is required. Enable it in lv_conf.h (LV_USE_CONT  1) "
-#endif
-
-#include "lv_cont.h"
 #include "../lv_core/lv_indev.h"
 
 /*********************
@@ -33,33 +27,9 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
-/** Possible states of a button.
- * It can be used not only by buttons but other button-like objects too*/
-enum {
-    LV_BTN_STATE_RELEASED,
-    LV_BTN_STATE_PRESSED,
-    LV_BTN_STATE_DISABLED,
-    LV_BTN_STATE_CHECKED_RELEASED,
-    LV_BTN_STATE_CHECKED_PRESSED,
-    LV_BTN_STATE_CHECKED_DISABLED,
-    _LV_BTN_STATE_LAST, /* Number of states*/
-};
-typedef uint8_t lv_btn_state_t;
-
-/** Extended data of button*/
-typedef struct {
-    /** Ext. of ancestor*/
-    lv_cont_ext_t cont;
-
-    /** 1: Toggle enabled*/
-    uint8_t checkable : 1;
-} lv_btn_ext_t;
-
 /**Styles*/
 enum {
     LV_BTN_PART_MAIN = LV_OBJ_PART_MAIN,
-    _LV_BTN_PART_VIRTUAL_LAST,
-    _LV_BTN_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
 };
 typedef uint8_t lv_btn_part_t;
 
@@ -69,152 +39,19 @@ typedef uint8_t lv_btn_part_t;
 
 /**
  * Create a button object
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new button
  * @return pointer to the created button
  */
-lv_obj_t * lv_btn_create(lv_obj_t * par, const lv_obj_t * copy);
+lv_obj_t * lv_btn_create(lv_obj_t * parent);
 
 /*=====================
  * Setter functions
  *====================*/
 
-/**
- * Enable the toggled states. On release the button will change from/to toggled state.
- * @param btn pointer to a button object
- * @param tgl true: enable toggled states, false: disable
- */
-void lv_btn_set_checkable(lv_obj_t * btn, bool tgl);
-
-/**
- * Set the state of the button
- * @param btn pointer to a button object
- * @param state the new state of the button (from lv_btn_state_t enum)
- */
-void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state);
-
-/**
- * Toggle the state of the button (ON->OFF, OFF->ON)
- * @param btn pointer to a button object
- */
-void lv_btn_toggle(lv_obj_t * btn);
-
-/**
- * Set the layout on a button
- * @param btn pointer to a button object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-static inline void lv_btn_set_layout(lv_obj_t * btn, lv_layout_t layout)
-{
-    lv_cont_set_layout(btn, layout);
-}
-
-/**
- * Set the fit policy in all 4 directions separately.
- * It tells how to change the button size automatically.
- * @param btn pointer to a button object
- * @param left left fit policy from `lv_fit_t`
- * @param right right fit policy from `lv_fit_t`
- * @param top top fit policy from `lv_fit_t`
- * @param bottom bottom fit policy from `lv_fit_t`
- */
-static inline void lv_btn_set_fit4(lv_obj_t * btn, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom)
-{
-    lv_cont_set_fit4(btn, left, right, top, bottom);
-}
-
-/**
- * Set the fit policy horizontally and vertically separately.
- * It tells how to change the button size automatically.
- * @param btn pointer to a button object
- * @param hor horizontal fit policy from `lv_fit_t`
- * @param ver vertical fit policy from `lv_fit_t`
- */
-static inline void lv_btn_set_fit2(lv_obj_t * btn, lv_fit_t hor, lv_fit_t ver)
-{
-    lv_cont_set_fit2(btn, hor, ver);
-}
-
-/**
- * Set the fit policy in all 4 direction at once.
- * It tells how to change the button size automatically.
- * @param btn pointer to a button object
- * @param fit fit policy from `lv_fit_t`
- */
-static inline void lv_btn_set_fit(lv_obj_t * btn, lv_fit_t fit)
-{
-    lv_cont_set_fit(btn, fit);
-}
-
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the current state of the button
- * @param btn pointer to a button object
- * @return the state of the button (from lv_btn_state_t enum)
- * If the button is in disabled state `LV_BTN_STATE_DISABLED` will be ORed to the other button states.
- */
-lv_btn_state_t lv_btn_get_state(const lv_obj_t * btn);
-
-/**
- * Get the toggle enable attribute of the button
- * @param btn pointer to a button object
- * @return true: checkable enabled, false: disabled
- */
-bool lv_btn_get_checkable(const lv_obj_t * btn);
-
-/**
- * Get the layout of a button
- * @param btn pointer to button object
- * @return the layout from 'lv_cont_layout_t'
- */
-static inline lv_layout_t lv_btn_get_layout(const lv_obj_t * btn)
-{
-    return lv_cont_get_layout(btn);
-}
-
-/**
- * Get the left fit mode
- * @param btn pointer to a button object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_btn_get_fit_left(const lv_obj_t * btn)
-{
-    return lv_cont_get_fit_left(btn);
-}
-
-/**
- * Get the right fit mode
- * @param btn pointer to a button object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_btn_get_fit_right(const lv_obj_t * btn)
-{
-    return lv_cont_get_fit_right(btn);
-}
-
-/**
- * Get the top fit mode
- * @param btn pointer to a button object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_btn_get_fit_top(const lv_obj_t * btn)
-{
-    return lv_cont_get_fit_top(btn);
-}
-
-/**
- * Get the bottom fit mode
- * @param btn pointer to a button object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_btn_get_fit_bottom(const lv_obj_t * btn)
-{
-    return lv_cont_get_fit_bottom(btn);
-}
-
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_widgets/lv_calendar.c b/src/lv_widgets/lv_calendar.c
deleted file mode 100644
index a95e08c2d..000000000
--- a/src/lv_widgets/lv_calendar.c
+++ /dev/null
@@ -1,1087 +0,0 @@
-/**
- * @file lv_calendar.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_calendar.h"
-#if LV_USE_CALENDAR != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_hal/lv_hal_indev.h"
-#include "../lv_misc/lv_utils.h"
-#include "../lv_core/lv_indev.h"
-#include "../lv_themes/lv_theme.h"
-#include <string.h>
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_calendar"
-
-/**********************
- *      TYPEDEFS
- **********************/
-enum {
-    DAY_DRAW_PREV_MONTH,
-    DAY_DRAW_ACT_MONTH,
-    DAY_DRAW_NEXT_MONTH,
-};
-typedef uint8_t day_draw_state_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_design_res_t lv_calendar_design(lv_obj_t * calendar, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_calendar_get_style(lv_obj_t * calendar, uint8_t part);
-static bool calculate_touched_day(lv_obj_t * calendar, const lv_point_t * touched_point);
-static lv_coord_t get_header_height(lv_obj_t * calendar);
-static lv_coord_t get_day_names_height(lv_obj_t * calendar);
-static void draw_header(lv_obj_t * calendar, const lv_area_t * mask);
-static void draw_day_names(lv_obj_t * calendar, const lv_area_t * mask);
-static void draw_dates(lv_obj_t * calendar, const lv_area_t * clip_area);
-static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day);
-static bool is_highlighted(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day);
-static bool is_pressed(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day);
-static const char * get_day_name(lv_obj_t * calendar, uint8_t day);
-static const char * get_month_name(lv_obj_t * calendar, int32_t month);
-static uint8_t get_month_length(int32_t year, int32_t month);
-static uint8_t is_leap_year(uint32_t year);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
-#if LV_CALENDAR_WEEK_STARTS_MONDAY != 0
-static const char * day_name[7]    = {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"};
-#else
-static const char * day_name[7]    = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
-#endif
-static const char * month_name[12] = {"January", "February", "March",     "April",   "May",      "June",
-                                      "July",    "August",   "September", "October", "November", "December"
-                                     };
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a calendar object
- * @param par pointer to an object, it will be the parent of the new calendar
- * @param copy pointer to a calendar object, if not NULL then the new object will be copied from it
- * @return pointer to the created calendar
- */
-lv_obj_t * lv_calendar_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("calendar create started");
-
-    /*Create the ancestor of calendar*/
-    lv_obj_t * calendar = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(calendar);
-    if(calendar == NULL) return NULL;
-
-    /*Allocate the calendar type specific extended data*/
-    lv_calendar_ext_t * ext = lv_obj_allocate_ext_attr(calendar, sizeof(lv_calendar_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(calendar);
-        return NULL;
-    }
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(calendar);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(calendar);
-
-    /*Initialize the allocated 'ext' */
-    ext->today.year  = 2020;
-    ext->today.month = 1;
-    ext->today.day   = 1;
-
-    ext->showed_date.year  = 2020;
-    ext->showed_date.month = 1;
-    ext->showed_date.day   = 1;
-
-    ext->pressed_date.year  = 0;
-    ext->pressed_date.month = 0;
-    ext->pressed_date.day   = 0;
-
-    ext->highlighted_dates      = NULL;
-    ext->highlighted_dates_num  = 0;
-    ext->day_names              = NULL;
-    ext->month_names            = NULL;
-
-    ext->btn_pressing = 0;
-
-
-    lv_style_list_init(&ext->style_date_nums);
-    lv_style_list_init(&ext->style_day_names);
-    lv_style_list_init(&ext->style_header);
-    ext->style_date_nums.skip_trans = 1;
-    ext->style_day_names.skip_trans = 1;
-    ext->style_header.skip_trans = 1;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(calendar, lv_calendar_signal);
-    lv_obj_set_design_cb(calendar, lv_calendar_design);
-
-    /*Init the new calendar calendar*/
-    if(copy == NULL) {
-        lv_theme_apply(calendar, LV_THEME_CALENDAR);
-
-        lv_obj_set_size(calendar, 5 * LV_DPI / 2, 5 * LV_DPI / 2);
-
-    }
-    /*Copy an existing calendar*/
-    else {
-        lv_calendar_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->today.year              = copy_ext->today.year;
-        ext->today.month             = copy_ext->today.month;
-        ext->today.day               = copy_ext->today.day;
-
-        ext->showed_date.year  = copy_ext->showed_date.year;
-        ext->showed_date.month = copy_ext->showed_date.month;
-        ext->showed_date.day   = copy_ext->showed_date.day;
-
-        ext->highlighted_dates     = copy_ext->highlighted_dates;
-        ext->highlighted_dates_num = copy_ext->highlighted_dates_num;
-        ext->day_names             = copy_ext->day_names;
-
-        ext->month_names            = copy_ext->month_names;
-        ext->style_header           = copy_ext->style_header;
-        ext->style_day_names        = copy_ext->style_day_names;
-        /*Refresh the style with new signal function*/
-        //        lv_obj_refresh_style(new_calendar);
-    }
-
-    LV_LOG_INFO("calendar created");
-
-    return calendar;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/*
- * New object specific "add" or "remove" functions come here
- */
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the today's date
- * @param calendar pointer to a calendar object
- * @param today pointer to an `lv_calendar_date_t` variable containing the date of today. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_today_date(lv_obj_t * calendar, lv_calendar_date_t * today)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(today);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->today.year         = today->year;
-    ext->today.month        = today->month;
-    ext->today.day          = today->day;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the currently showed
- * @param calendar pointer to a calendar object
- * @param showed pointer to an `lv_calendar_date_t` variable containing the date to show. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_showed_date(lv_obj_t * calendar, lv_calendar_date_t * showed)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(showed);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->showed_date.year   = showed->year;
-    ext->showed_date.month  = showed->month;
-    ext->showed_date.day    = showed->day;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the the highlighted dates
- * @param calendar pointer to a calendar object
- * @param highlighted pointer to an `lv_calendar_date_t` array containing the dates. ONLY A POINTER
- * WILL BE SAVED! CAN'T BE LOCAL ARRAY.
- * @param date_num number of dates in the array
- */
-void lv_calendar_set_highlighted_dates(lv_obj_t * calendar, lv_calendar_date_t highlighted[], uint16_t date_num)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(highlighted);
-
-    lv_calendar_ext_t * ext    = lv_obj_get_ext_attr(calendar);
-    ext->highlighted_dates     = highlighted;
-    ext->highlighted_dates_num = date_num;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the name of the days
- * @param calendar pointer to a calendar object
- * @param day_names pointer to an array with the names. E.g. `const char * days[7] = {"Sun", "Mon",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(day_names);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->day_names          = day_names;
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the name of the month
- * @param calendar pointer to a calendar object
- * @param month_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** month_names)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(month_names);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->month_names        = month_names;
-    lv_obj_invalidate(calendar);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the today's date
- * @param calendar pointer to a calendar object
- * @return return pointer to an `lv_calendar_date_t` variable containing the date of today.
- */
-lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return &ext->today;
-}
-
-/**
- * Get the currently showed
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the date is being shown.
- */
-lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return &ext->showed_date;
-}
-
-/**
- * Get the the pressed date.
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the pressed date.
- * `NULL` if not date pressed (e.g. the header)
- */
-lv_calendar_date_t * lv_calendar_get_pressed_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->pressed_date.year != 0 ? &ext->pressed_date : NULL;
-}
-
-/**
- * Get the the highlighted dates
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` array containing the dates.
- */
-lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->highlighted_dates;
-}
-
-/**
- * Get the number of the highlighted dates
- * @param calendar pointer to a calendar object
- * @return number of highlighted days
- */
-uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->highlighted_dates_num;
-}
-
-/**
- * Get the name of the days
- * @param calendar pointer to a calendar object
- * @return pointer to the array of day names
- */
-const char ** lv_calendar_get_day_names(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->day_names;
-}
-
-/**
- * Get the name of the month
- * @param calendar pointer to a calendar object
- * @return pointer to the array of month names
- */
-const char ** lv_calendar_get_month_names(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->month_names;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/*
- * New object specific "other" functions come here
- */
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the calendars
- * @param calendar pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_calendar_design(lv_obj_t * calendar, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_design(calendar, clip_area, mode);
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_design(calendar, clip_area, mode);
-
-        draw_header(calendar, clip_area);
-        draw_day_names(calendar, clip_area);
-        draw_dates(calendar, clip_area);
-
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design(calendar, clip_area, mode);
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
-/**
- * Signal function of the calendar
- * @param calendar pointer to a calendar object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_calendar_get_style(calendar, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(calendar, sign, param);
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(calendar, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_HEADER);
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_DAY_NAMES);
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_DATE);
-    }
-    else if(sign == LV_SIGNAL_PRESSING) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        lv_area_t header_area;
-        lv_area_copy(&header_area, &calendar->coords);
-        header_area.y2 = header_area.y1 + get_header_height(calendar);
-
-        lv_indev_t * indev = lv_indev_get_act();
-        lv_point_t p;
-        lv_indev_get_point(indev, &p);
-
-        /*If the header is pressed mark an arrow as pressed*/
-        if(_lv_area_is_point_on(&header_area, &p, 0)) {
-            if(p.x < header_area.x1 + lv_area_get_width(&header_area) / 2) {
-                if(ext->btn_pressing != -1) lv_obj_invalidate(calendar);
-                ext->btn_pressing = -1;
-            }
-            else {
-                if(ext->btn_pressing != 1) lv_obj_invalidate(calendar);
-                ext->btn_pressing = 1;
-            }
-
-            ext->pressed_date.year  = 0;
-            ext->pressed_date.month = 0;
-            ext->pressed_date.day   = 0;
-        }
-        /*If a day is pressed save it*/
-        else if(calculate_touched_day(calendar, &p)) {
-            ext->btn_pressing = 0;
-            lv_obj_invalidate(calendar);
-        }
-        /*Else set a default state*/
-        else {
-            if(ext->btn_pressing != 0) lv_obj_invalidate(calendar);
-            ext->btn_pressing       = 0;
-            ext->pressed_date.year  = 0;
-            ext->pressed_date.month = 0;
-            ext->pressed_date.day   = 0;
-        }
-    }
-    else if(sign == LV_SIGNAL_PRESS_LOST) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        ext->btn_pressing       = 0;
-        ext->pressed_date.year  = 0;
-        ext->pressed_date.month = 0;
-        ext->pressed_date.day   = 0;
-        lv_obj_invalidate(calendar);
-
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(ext->btn_pressing < 0) {
-            if(ext->showed_date.month <= 1) {
-                ext->showed_date.month = 12;
-                ext->showed_date.year--;
-            }
-            else {
-                ext->showed_date.month--;
-            }
-        }
-        else if(ext->btn_pressing > 0) {
-            if(ext->showed_date.month >= 12) {
-                ext->showed_date.month = 1;
-                ext->showed_date.year++;
-            }
-            else {
-                ext->showed_date.month++;
-            }
-        }
-        else if(ext->pressed_date.year != 0) {
-            res = lv_event_send(calendar, LV_EVENT_VALUE_CHANGED, NULL);
-            if(res != LV_RES_OK) return res;
-
-        }
-
-        ext->btn_pressing = 0;
-        ext->pressed_date.year  = 0;
-        ext->pressed_date.month = 0;
-        ext->pressed_date.day   = 0;
-        lv_obj_invalidate(calendar);
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        uint8_t c               = *((uint8_t *)param);
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
-            if(ext->showed_date.month >= 12) {
-                ext->showed_date.month = 1;
-                ext->showed_date.year++;
-            }
-            else {
-                ext->showed_date.month++;
-            }
-            lv_obj_invalidate(calendar);
-        }
-        else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
-            if(ext->showed_date.month <= 1) {
-                ext->showed_date.month = 12;
-                ext->showed_date.year--;
-            }
-            else {
-                ext->showed_date.month--;
-            }
-            lv_obj_invalidate(calendar);
-        }
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param page pointer the object
- * @param part the part from `lv_calendar_part_t`. (LV_CALENDAR_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_calendar_get_style(lv_obj_t * calendar, uint8_t part)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    lv_style_list_t * style_dsc_p;
-
-
-    switch(part) {
-        case LV_CALENDAR_PART_BG:
-            style_dsc_p = &calendar->style_list;
-            break;
-        case LV_CALENDAR_PART_HEADER:
-            style_dsc_p = &ext->style_header;
-            break;
-        case LV_CALENDAR_PART_DAY_NAMES:
-            style_dsc_p = &ext->style_day_names;
-            break;
-        case LV_CALENDAR_PART_DATE:
-            style_dsc_p = &ext->style_date_nums;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * It will check if the days part of calendar is touched
- * and if it is, it will calculate the day and put it in pressed_date of calendar object.
- * @param calendar pointer to a calendar object
- * @param pointer to a point
- * @return true: days part of calendar is touched and its related date is put in pressed date
- * false: the point is out of days part area.
- */
-static bool calculate_touched_day(lv_obj_t * calendar, const lv_point_t * touched_point)
-{
-    lv_area_t days_area;
-    lv_area_copy(&days_area, &calendar->coords);
-    lv_style_int_t left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-
-    days_area.x1 += left;
-    days_area.x2 -= right;
-    days_area.y1 = calendar->coords.y1 + get_header_height(calendar) + get_day_names_height(calendar) + top;
-    days_area.y2 -= bottom;
-
-    if(_lv_area_is_point_on(&days_area, touched_point, 0)) {
-        lv_coord_t w  = (days_area.x2 - days_area.x1 + 1) / 7;
-        lv_coord_t h  = (days_area.y2 - days_area.y1 + 1) / 6;
-        uint8_t x_pos = 0;
-        x_pos         = (touched_point->x - days_area.x1) / w;
-        if(x_pos > 6) x_pos = 6;
-        uint8_t y_pos = 0;
-        y_pos         = (touched_point->y - days_area.y1) / h;
-        if(y_pos > 5) y_pos = 5;
-
-        uint8_t i_pos           = 0;
-        i_pos                   = (y_pos * 7) + x_pos;
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(i_pos < get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1)) {
-            ext->pressed_date.year  = ext->showed_date.year - (ext->showed_date.month == 1 ? 1 : 0);
-            ext->pressed_date.month = ext->showed_date.month == 1 ? 12 : (ext->showed_date.month - 1);
-            ext->pressed_date.day   = get_month_length(ext->pressed_date.year, ext->pressed_date.month) -
-                                      get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) + 1 + i_pos;
-        }
-        else if(i_pos < (get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) +
-                         get_month_length(ext->showed_date.year, ext->showed_date.month))) {
-            ext->pressed_date.year  = ext->showed_date.year;
-            ext->pressed_date.month = ext->showed_date.month;
-            ext->pressed_date.day   = i_pos + 1 - get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1);
-        }
-        else if(i_pos < 42) {
-            ext->pressed_date.year  = ext->showed_date.year + (ext->showed_date.month == 12 ? 1 : 0);
-            ext->pressed_date.month = ext->showed_date.month == 12 ? 1 : (ext->showed_date.month + 1);
-            ext->pressed_date.day   = i_pos + 1 - get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) -
-                                      get_month_length(ext->showed_date.year, ext->showed_date.month);
-        }
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-
-/**
- * Get the height of a calendar's header based on it's style
- * @param calendar point to a calendar
- * @return the header's height
- */
-static lv_coord_t get_header_height(lv_obj_t * calendar)
-{
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_HEADER);
-
-    return lv_font_get_line_height(font) + top + bottom;
-}
-
-/**
- * Get the height of a calendar's day_names based on it's style
- * @param calendar point to a calendar
- * @return the day_names's height
- */
-static lv_coord_t get_day_names_height(lv_obj_t * calendar)
-{
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DAY_NAMES);
-
-    return lv_font_get_line_height(font) + top + bottom;
-}
-
-/**
- * Draw the calendar header with month name and arrows
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_header(lv_obj_t * calendar, const lv_area_t * mask)
-{
-    lv_style_int_t header_top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t header_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t header_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_HEADER);
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_HEADER);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-    lv_area_t header_area;
-    header_area.x1 = calendar->coords.x1;
-    header_area.x2 = calendar->coords.x2;
-    header_area.y1 = calendar->coords.y1 + header_top;
-    header_area.y2 = header_area.y1 + lv_font_get_line_height(font);
-
-    lv_draw_rect_dsc_t header_rect_dsc;
-    lv_draw_rect_dsc_init(&header_rect_dsc);
-    lv_obj_init_draw_rect_dsc(calendar, LV_CALENDAR_PART_HEADER, &header_rect_dsc);
-    lv_draw_rect(&header_area, mask, &header_rect_dsc);
-
-    lv_state_t state_ori = calendar->state;
-
-    /*Add the year + month name*/
-    char txt_buf[64];
-    _lv_utils_num_to_str(ext->showed_date.year, txt_buf);
-    txt_buf[4] = ' ';
-    txt_buf[5] = '\0';
-    strcpy(&txt_buf[5], get_month_name(calendar, ext->showed_date.month));
-
-    calendar->state = LV_STATE_DEFAULT;
-    _lv_obj_disable_style_caching(calendar, true);
-
-    lv_draw_label_dsc_t label_dsc;
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    label_dsc.flag = LV_TXT_FLAG_CENTER;
-    lv_draw_label(&header_area, mask, &label_dsc, txt_buf, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-
-    /*Add the left arrow*/
-    if(ext->btn_pressing < 0) calendar->state |= LV_STATE_PRESSED;
-    else calendar->state &= ~(LV_STATE_PRESSED);
-
-    header_area.x1 += header_left;
-
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    lv_draw_label(&header_area, mask, &label_dsc, LV_SYMBOL_LEFT, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-
-    /*Add the right arrow*/
-    if(ext->btn_pressing > 0) calendar->state |= LV_STATE_PRESSED;
-    else calendar->state &= ~(LV_STATE_PRESSED);
-
-    header_area.x1 = header_area.x2 - header_right - _lv_txt_get_width(LV_SYMBOL_RIGHT, (uint16_t)strlen(LV_SYMBOL_RIGHT),
-                                                                       font, 0, LV_TXT_FLAG_NONE);
-
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    lv_draw_label(&header_area, mask, &label_dsc, LV_SYMBOL_RIGHT, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-    _lv_obj_disable_style_caching(calendar, false);
-}
-
-/**
- * Draw the day's name below the header
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_day_names(lv_obj_t * calendar, const lv_area_t * mask)
-{
-    lv_style_int_t date_top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_inner = lv_obj_get_style_pad_inner(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_coord_t days_w      = lv_obj_get_width(calendar) - date_left - date_right;
-    lv_coord_t box_w      = (days_w - date_inner * 6) / 7;
-    lv_coord_t days_y1 = calendar->coords.y1 + date_top + get_header_height(calendar) + get_day_names_height(calendar);
-    lv_coord_t days_h = calendar->coords.y2 - days_y1 - date_bottom;
-    lv_coord_t box_h      = (days_h - 5 * date_inner) / 6;
-    lv_coord_t box_size = LV_MATH_MIN(box_w, box_h);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DAY_NAMES);
-
-    lv_coord_t w = lv_obj_get_width(calendar) - left - right;
-
-    lv_coord_t label_w = w / 6;
-
-    lv_area_t label_area;
-    label_area.y1 = calendar->coords.y1 + get_header_height(calendar) + top;
-    label_area.y2 = label_area.y1 + lv_font_get_line_height(font);
-
-    lv_draw_label_dsc_t label_dsc;
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_DAY_NAMES, &label_dsc);
-    label_dsc.flag = LV_TXT_FLAG_CENTER;
-
-    uint32_t i;
-    for(i = 0; i < 7; i++) {
-        label_area.x1 = calendar->coords.x1 + ((w - box_size) * i) / 6  + box_size / 2 - label_w / 2 + left;
-        label_area.x2 = label_area.x1 + label_w - 1;
-
-        lv_draw_label(&label_area, mask, &label_dsc, get_day_name(calendar, i), NULL);
-    }
-}
-
-/**
- * Draw the date numbers in a matrix
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_dates(lv_obj_t * calendar, const lv_area_t * clip_area)
-{
-    lv_calendar_ext_t * ext     = lv_obj_get_ext_attr(calendar);
-
-    const lv_font_t * nums_font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_style_int_t date_top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_inner = lv_obj_get_style_pad_inner(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_coord_t days_y1 = calendar->coords.y1 + date_top + get_header_height(calendar) + get_day_names_height(calendar);
-    lv_coord_t days_h = calendar->coords.y2 - days_y1 - date_bottom;
-
-    /*The state changes without re-caching the styles, disable the use of cache*/
-    lv_state_t state_ori = calendar->state;
-    calendar->state = LV_STATE_DEFAULT;
-    _lv_obj_disable_style_caching(calendar, true);
-
-    lv_state_t month_state = LV_STATE_DISABLED;
-
-    uint8_t day_cnt;
-    lv_coord_t days_w      = lv_obj_get_width(calendar) - date_left - date_right;
-    lv_coord_t box_w      = (days_w - date_inner * 6) / 7;
-    lv_coord_t box_h      = (days_h - 5 * date_inner) / 6;
-    lv_coord_t box_size = LV_MATH_MIN(box_w, box_h);
-
-    uint8_t month_start_day = get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1);
-
-    day_draw_state_t draw_state;
-
-    /*If starting with the first day of the week then the previous month is not visible*/
-    if(month_start_day == 0) {
-        day_cnt    = 1;
-        draw_state = DAY_DRAW_ACT_MONTH;
-        month_state  = 0;
-    }
-    else {
-        draw_state = DAY_DRAW_PREV_MONTH;
-        day_cnt = get_month_length(ext->showed_date.year, ext->showed_date.month - 1); /*Length of the previous month*/
-        day_cnt -= month_start_day - 1; /*First visible number of the previous month*/
-        month_state = LV_STATE_DISABLED;
-    }
-
-    bool month_of_today_shown = false;
-    if(ext->showed_date.year == ext->today.year && ext->showed_date.month == ext->today.month) {
-        month_of_today_shown = true;
-    }
-
-    char buf[3];
-
-    /*Draw 6 weeks*/
-    lv_draw_rect_dsc_t rect_dsc;
-    lv_draw_label_dsc_t label_dsc;
-    lv_state_t prev_state = 0xFF;
-    uint32_t week;
-    for(week = 0; week < 6; week++) {
-        lv_area_t box_area;
-
-        box_area.y1 = days_y1 + ((days_h - box_size) * week) / 5;
-        box_area.y2 = box_area.y1 + box_size - 1;
-
-        if(box_area.y1 > clip_area->y2) {
-            calendar->state = state_ori;
-            _lv_obj_disable_style_caching(calendar, false);
-            return;
-        }
-
-        lv_area_t label_area;
-        label_area.y1 = box_area.y1 + (lv_area_get_height(&box_area) - lv_font_get_line_height(nums_font)) / 2;
-        label_area.y2 = label_area.y1 + lv_font_get_line_height(nums_font);
-
-        /*Draw the 7 days of a week*/
-        uint32_t day;
-        for(day = 0; day < 7; day++) {
-            /*The previous month is over*/
-            if(draw_state == DAY_DRAW_PREV_MONTH && day == month_start_day) {
-                draw_state = DAY_DRAW_ACT_MONTH;
-                day_cnt    = 1;
-                month_state  = 0;
-            }
-            /*The current month is over*/
-            else if(draw_state == DAY_DRAW_ACT_MONTH &&
-                    day_cnt > get_month_length(ext->showed_date.year, ext->showed_date.month)) {
-                draw_state = DAY_DRAW_NEXT_MONTH;
-                day_cnt    = 1;
-                month_state  = LV_STATE_DISABLED;
-            }
-
-            if(box_area.y2 < clip_area->y1) {
-                day_cnt++;
-                continue;
-            }
-
-            lv_state_t day_state = month_state;
-            if(is_pressed(calendar, draw_state, ext->showed_date.year, ext->showed_date.month, day_cnt)) {
-                day_state |= LV_STATE_PRESSED;
-            }
-            if(is_highlighted(calendar, draw_state, ext->showed_date.year, ext->showed_date.month, day_cnt)) {
-                day_state |= LV_STATE_CHECKED;
-            }
-            if(month_of_today_shown && day_cnt == ext->today.day && draw_state == DAY_DRAW_ACT_MONTH) {
-                day_state |= LV_STATE_FOCUSED;
-            }
-
-            if(prev_state != day_state) {
-                lv_draw_rect_dsc_init(&rect_dsc);
-                lv_draw_label_dsc_init(&label_dsc);
-                label_dsc.flag = LV_TXT_FLAG_CENTER;
-
-                calendar->state = day_state;
-                lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_DATE, &label_dsc);
-                lv_obj_init_draw_rect_dsc(calendar, LV_CALENDAR_PART_DATE, &rect_dsc);
-
-                prev_state = day_state;
-            }
-
-            label_area.x1 = calendar->coords.x1 + ((days_w - box_size) * day) / 6 + date_left;
-            label_area.x2 = label_area.x1 + box_size - 1;
-
-            box_area.x1 = label_area.x1;
-            box_area.x2 = label_area.x2;
-
-
-            lv_draw_rect(&box_area, clip_area, &rect_dsc);
-
-            /*Write the day's number*/
-            _lv_utils_num_to_str(day_cnt, buf);
-            lv_draw_label(&label_area, clip_area, &label_dsc, buf, NULL);
-
-            /*Go to the next day*/
-            day_cnt++;
-        }
-    }
-    calendar->state = state_ori;
-    _lv_obj_disable_style_caching(calendar, false);
-
-
-}
-
-/**
- * Check weather a date is highlighted or not
- * @param calendar pointer to a calendar object
- * @param draw_state which month is drawn (previous, active, next)
- * @param year a year
- * @param month a  month [1..12]
- * @param day a day [1..31]
- * @return true: highlighted
- */
-static bool is_highlighted(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day)
-{
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-
-    if(draw_state == DAY_DRAW_PREV_MONTH) {
-        year -= month == 1 ? 1 : 0;
-        month = month == 1 ? 12 : month - 1;
-    }
-    else if(draw_state == DAY_DRAW_NEXT_MONTH) {
-        year += month == 12 ? 1 : 0;
-        month = month == 12 ? 1 : month + 1;
-    }
-
-    uint32_t i;
-    for(i = 0; i < ext->highlighted_dates_num; i++) {
-        if(ext->highlighted_dates[i].year == year && ext->highlighted_dates[i].month == month &&
-           ext->highlighted_dates[i].day == day) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Check weather a date is highlighted or not
- * @param calendar pointer to a calendar object
- * @param draw_state which month is drawn (previous, active, next)
- * @param year a year
- * @param month a  month [1..12]
- * @param day a day [1..31]
- * @return true: highlighted
- */
-static bool is_pressed(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day)
-{
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-
-    if(draw_state == DAY_DRAW_PREV_MONTH) {
-        year -= month == 1 ? 1 : 0;
-        month = month == 1 ? 12 : month - 1;
-    }
-    else if(draw_state == DAY_DRAW_NEXT_MONTH) {
-        year += month == 12 ? 1 : 0;
-        month = month == 12 ? 1 : month + 1;
-    }
-
-    if(year == ext->pressed_date.year && month == ext->pressed_date.month && day == ext->pressed_date.day) return true;
-    else return false;
-}
-/**
- * Get the day name
- * @param calendar pointer to a calendar object
- * @param day a day in [0..6]
- * @return
- */
-static const char * get_day_name(lv_obj_t * calendar, uint8_t day)
-{
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    if(ext->day_names)
-        return ext->day_names[day];
-    else
-        return day_name[day];
-}
-
-/**
- * Get the month name
- * @param calendar pointer to a calendar object
- * @param month a month. The range is basically [1..12] but [-11..1] is also supported to handle
- * previous year
- * @return
- */
-static const char * get_month_name(lv_obj_t * calendar, int32_t month)
-{
-    month--; /*Range of months id [1..12] but range of indexes is [0..11]*/
-    if(month < 0) month = 12 + month;
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    if(ext->month_names)
-        return ext->month_names[month];
-    else
-        return month_name[month];
-}
-
-/**
- * Get the number of days in a month
- * @param year a year
- * @param month a month. The range is basically [1..12] but [-11..1] is also supported to handle
- * previous year
- * @return [28..31]
- */
-static uint8_t get_month_length(int32_t year, int32_t month)
-{
-    month--; /*Range of months id [1..12] but range of indexes is [0..11]*/
-    if(month < 0) {
-        year--;             /*Already in the previous year (won't be less then -12 to skip a whole year)*/
-        month = 12 + month; /*`month` is negative, the result will be < 12*/
-    }
-    if(month >= 12) {
-        year++;
-        month -= 12;
-    }
-
-    /*month == 1 is february*/
-    return (month == 1) ? (28 + is_leap_year(year)) : 31 - month % 7 % 2;
-}
-
-/**
- * Tells whether a year is leap year or not
- * @param year a year
- * @return 0: not leap year; 1: leap year
- */
-static uint8_t is_leap_year(uint32_t year)
-{
-    return (year % 4) || ((year % 100 == 0) && (year % 400)) ? 0 : 1;
-}
-
-/**
- * Get the day of the week
- * @param year a year
- * @param month a  month
- * @param day a day
- * @return [0..6] which means [Sun..Sat] or [Mon..Sun] depending on LV_CALENDAR_WEEK_STARTS_MONDAY
- */
-static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day)
-{
-    uint32_t a = month < 3 ? 1 : 0;
-    uint32_t b = year - a;
-
-#if LV_CALENDAR_WEEK_STARTS_MONDAY
-    uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400) - 1) % 7;
-#else
-    uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400)) % 7;
-#endif
-
-    return day_of_week;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_calendar.h b/src/lv_widgets/lv_calendar.h
deleted file mode 100644
index 1e0f88cdc..000000000
--- a/src/lv_widgets/lv_calendar.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/**
- * @file lv_calendar.h
- *
- */
-
-#ifndef LV_CALENDAR_H
-#define LV_CALENDAR_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_CALENDAR != 0
-
-#include "../lv_core/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**
- * Represents a date on the calendar object (platform-agnostic).
- */
-typedef struct {
-    uint16_t year;
-    int8_t month;
-    int8_t day;
-} lv_calendar_date_t;
-
-/*Data of calendar*/
-typedef struct {
-    /*None*/ /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_calendar_date_t today;               /*Date of today*/
-    lv_calendar_date_t showed_date;         /*Currently visible month (day is ignored)*/
-    lv_calendar_date_t * highlighted_dates; /*Apply different style on these days (pointer to an
-                                               array defined by the user)*/
-    int8_t btn_pressing;                    /*-1: prev month pressing, +1 next month pressing on the header*/
-    uint16_t highlighted_dates_num;          /*Number of elements in `highlighted_days`*/
-    lv_calendar_date_t pressed_date;
-    const char ** day_names;   /*Pointer to an array with the name of the days (NULL: use default names)*/
-    const char ** month_names; /*Pointer to an array with the name of the month (NULL. use default names)*/
-
-    /*Styles*/
-    lv_style_list_t style_header;
-    lv_style_list_t style_day_names;
-    lv_style_list_t style_date_nums;
-} lv_calendar_ext_t;
-
-/** Calendar parts*/
-enum {
-    LV_CALENDAR_PART_BG, /**< Background and "normal" date numbers style */
-    LV_CALENDAR_PART_HEADER, /** Calendar header style */
-    LV_CALENDAR_PART_DAY_NAMES, /** Day name style */
-    LV_CALENDAR_PART_DATE, /** Day name style */
-};
-typedef uint8_t lv_calendar_part_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a calendar objects
- * @param par pointer to an object, it will be the parent of the new calendar
- * @param copy pointer to a calendar object, if not NULL then the new object will be copied from it
- * @return pointer to the created calendar
- */
-lv_obj_t * lv_calendar_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the today's date
- * @param calendar pointer to a calendar object
- * @param today pointer to an `lv_calendar_date_t` variable containing the date of today. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_today_date(lv_obj_t * calendar, lv_calendar_date_t * today);
-
-/**
- * Set the currently showed
- * @param calendar pointer to a calendar object
- * @param showed pointer to an `lv_calendar_date_t` variable containing the date to show. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_showed_date(lv_obj_t * calendar, lv_calendar_date_t * showed);
-
-/**
- * Set the the highlighted dates
- * @param calendar pointer to a calendar object
- * @param highlighted pointer to an `lv_calendar_date_t` array containing the dates. ONLY A POINTER
- * WILL BE SAVED! CAN'T BE LOCAL ARRAY.
- * @param date_num number of dates in the array
- */
-void lv_calendar_set_highlighted_dates(lv_obj_t * calendar, lv_calendar_date_t highlighted[], uint16_t date_num);
-
-/**
- * Set the name of the days
- * @param calendar pointer to a calendar object
- * @param day_names pointer to an array with the names. E.g. `const char * days[7] = {"Sun", "Mon",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names);
-
-/**
- * Set the name of the month
- * @param calendar pointer to a calendar object
- * @param month_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** month_names);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the today's date
- * @param calendar pointer to a calendar object
- * @return return pointer to an `lv_calendar_date_t` variable containing the date of today.
- */
-lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar);
-
-/**
- * Get the currently showed
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the date is being shown.
- */
-lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar);
-
-/**
- * Get the the pressed date.
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the pressed date.
- *         `NULL` if not date pressed (e.g. the header)
- */
-lv_calendar_date_t * lv_calendar_get_pressed_date(const lv_obj_t * calendar);
-
-/**
- * Get the the highlighted dates
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` array containing the dates.
- */
-lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar);
-
-/**
- * Get the number of the highlighted dates
- * @param calendar pointer to a calendar object
- * @return number of highlighted days
- */
-uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar);
-
-/**
- * Get the name of the days
- * @param calendar pointer to a calendar object
- * @return pointer to the array of day names
- */
-const char ** lv_calendar_get_day_names(const lv_obj_t * calendar);
-
-/**
- * Get the name of the month
- * @param calendar pointer to a calendar object
- * @return pointer to the array of month names
- */
-const char ** lv_calendar_get_month_names(const lv_obj_t * calendar);
-
-/*=====================
- * Other functions
- *====================*/
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_CALENDAR*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_CALENDAR_H*/
diff --git a/src/lv_widgets/lv_cont.c b/src/lv_widgets/lv_cont.c
deleted file mode 100644
index 04a81343e..000000000
--- a/src/lv_widgets/lv_cont.c
+++ /dev/null
@@ -1,795 +0,0 @@
-/**
- * @file lv_cont.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "lv_cont.h"
-#if LV_USE_CONT != 0
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_draw/lv_draw_mask.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_area.h"
-#include "../lv_misc/lv_color.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_cont"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_cont_get_style(lv_obj_t * cont, uint8_t type);
-static void lv_cont_refr_layout(lv_obj_t * cont);
-static void lv_cont_layout_col(lv_obj_t * cont);
-static void lv_cont_layout_row(lv_obj_t * cont);
-static void lv_cont_layout_center(lv_obj_t * cont);
-static void lv_cont_layout_pretty(lv_obj_t * cont);
-static void lv_cont_layout_grid(lv_obj_t * cont);
-static void lv_cont_refr_autofit(lv_obj_t * cont);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_cb_t ancestor_design;
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a container objects
- * @param par pointer to an object, it will be the parent of the new container
- * @param copy pointer to a container object, if not NULL then the new object will be copied from it
- * @return pointer to the created container
- */
-lv_obj_t * lv_cont_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-
-    LV_LOG_TRACE("container create started");
-
-    /*Create a basic object*/
-    lv_obj_t * cont = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(cont);
-    if(cont == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(cont);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(cont);
-
-    lv_obj_allocate_ext_attr(cont, sizeof(lv_cont_ext_t));
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext == NULL) {
-        lv_obj_del(cont);
-        return NULL;
-    }
-
-    LV_ASSERT_MEM(ext);
-    ext->fit_left   = LV_FIT_NONE;
-    ext->fit_right  = LV_FIT_NONE;
-    ext->fit_top    = LV_FIT_NONE;
-    ext->fit_bottom = LV_FIT_NONE;
-    ext->layout     = LV_LAYOUT_OFF;
-
-    lv_obj_set_signal_cb(cont, lv_cont_signal);
-
-    /*Init the new container*/
-    if(copy == NULL) {
-        /*Set the default styles if it's not screen*/
-        if(par != NULL) {
-            lv_theme_apply(cont, LV_THEME_CONT);
-        }
-
-
-    }
-    /*Copy an existing object*/
-    else {
-        lv_cont_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->fit_left            = copy_ext->fit_left;
-        ext->fit_right           = copy_ext->fit_right;
-        ext->fit_top             = copy_ext->fit_top;
-        ext->fit_bottom          = copy_ext->fit_bottom;
-        ext->layout              = copy_ext->layout;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(cont, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("container created");
-
-    return cont;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a layout on a container
- * @param cont pointer to a container object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext->layout == layout) return;
-
-    ext->layout = layout;
-
-    /*Send a signal to refresh the layout*/
-    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
-}
-
-/**
- * Set the fit policy in all 4 directions separately.
- * It tell how to change the container's size automatically.
- * @param cont pointer to a container object
- * @param left left fit policy from `lv_fit_t`
- * @param right right fit policy from `lv_fit_t`
- * @param top bottom fit policy from `lv_fit_t`
- * @param bottom bottom fit policy from `lv_fit_t`
- */
-void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_obj_invalidate(cont);
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext->fit_left == left && ext->fit_right == right && ext->fit_top == top && ext->fit_bottom == bottom) {
-        return;
-    }
-
-    ext->fit_left   = left;
-    ext->fit_right  = right;
-    ext->fit_top    = top;
-    ext->fit_bottom = bottom;
-
-    /*Send a signal to refresh the layout*/
-    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the layout of a container
- * @param cont pointer to container object
- * @return the layout from 'lv_cont_layout_t'
- */
-lv_layout_t lv_cont_get_layout(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->layout;
-}
-
-/**
- * Get left fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_left(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_left;
-}
-
-/**
- * Get right fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_right(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_right;
-}
-
-/**
- * Get top fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_top(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_top;
-}
-
-/**
- * Get bottom fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_bottom(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_bottom;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the container
- * @param cont pointer to a container object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
-{
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_cont_get_style(cont, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(cont, sign, param);
-    }
-
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(cont, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_STYLE_CHG) { /*Recalculate the padding if the style changed*/
-        lv_cont_refr_layout(cont);
-        lv_cont_refr_autofit(cont);
-    }
-    else if(sign == LV_SIGNAL_CHILD_CHG) {
-        lv_cont_refr_layout(cont);
-        lv_cont_refr_autofit(cont);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(lv_obj_get_width(cont) != lv_area_get_width(param) || lv_obj_get_height(cont) != lv_area_get_height(param)) {
-            lv_cont_refr_layout(cont);
-            lv_cont_refr_autofit(cont);
-        }
-    }
-    else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
-        /*MAX and EDGE fit needs to be refreshed if the parent's size has changed*/
-        lv_cont_refr_autofit(cont);
-    }
-
-    return res;
-}
-
-
-static lv_style_list_t * lv_cont_get_style(lv_obj_t * cont, uint8_t type)
-{
-    lv_style_list_t * style_dsc_p;
-    switch(type) {
-        case LV_CONT_PART_MAIN:
-            style_dsc_p = &cont->style_list;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * Refresh the layout of a container
- * @param cont pointer to an object which layout should be refreshed
- */
-static void lv_cont_refr_layout(lv_obj_t * cont)
-{
-    if(lv_obj_is_protected(cont, LV_PROTECT_CHILD_CHG)) return;
-    lv_layout_t type = lv_cont_get_layout(cont);
-
-    /*'cont' has to be at least 1 child*/
-    if(lv_obj_get_child(cont, NULL) == NULL) return;
-
-    if(type == LV_LAYOUT_OFF) return;
-
-    if(type == LV_LAYOUT_CENTER) {
-        lv_cont_layout_center(cont);
-    }
-    else if(type == LV_LAYOUT_COLUMN_LEFT || type == LV_LAYOUT_COLUMN_MID || type == LV_LAYOUT_COLUMN_RIGHT) {
-        lv_cont_layout_col(cont);
-    }
-    else if(type == LV_LAYOUT_ROW_TOP || type == LV_LAYOUT_ROW_MID || type == LV_LAYOUT_ROW_BOTTOM) {
-        lv_cont_layout_row(cont);
-    }
-    else if(type == LV_LAYOUT_PRETTY_MID || type == LV_LAYOUT_PRETTY_TOP || type == LV_LAYOUT_PRETTY_BOTTOM) {
-        lv_cont_layout_pretty(cont);
-    }
-    else if(type == LV_LAYOUT_GRID) {
-        lv_cont_layout_grid(cont);
-    }
-}
-
-/**
- * Handle column type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_col(lv_obj_t * cont)
-{
-    lv_coord_t left = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t right = lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    lv_coord_t top = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    lv_layout_t type = lv_cont_get_layout(cont);
-    lv_obj_t * child;
-
-    /*Adjust margin and get the alignment type*/
-    lv_align_t align;
-    lv_coord_t hpad_corr;
-
-    switch(type) {
-        case LV_LAYOUT_COLUMN_LEFT:
-            hpad_corr = left;
-            align     = LV_ALIGN_IN_TOP_LEFT;
-            break;
-        case LV_LAYOUT_COLUMN_MID:
-            hpad_corr = 0;
-            align     = LV_ALIGN_IN_TOP_MID;
-            break;
-        case LV_LAYOUT_COLUMN_RIGHT:
-            hpad_corr = -right;
-            align     = LV_ALIGN_IN_TOP_RIGHT;
-            break;
-        default:
-            hpad_corr = 0;
-            align     = LV_ALIGN_IN_TOP_LEFT;
-            break;
-    }
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-    /* Align the children */
-    lv_coord_t last_cord = top;
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        lv_style_int_t mtop = lv_obj_get_style_margin_top(child, LV_OBJ_PART_MAIN);
-        lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN);
-        lv_style_int_t mleft = lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN);
-        lv_obj_align(child, cont, align, hpad_corr + mleft, last_cord + mtop);
-        last_cord += lv_obj_get_height(child) + inner + mtop + mbottom;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle row type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_row(lv_obj_t * cont)
-{
-
-    lv_layout_t type = lv_cont_get_layout(cont);
-    lv_obj_t * child;
-
-    /*Adjust margin and get the alignment type*/
-    lv_align_t align;
-    lv_coord_t vpad_corr;
-    lv_bidi_dir_t base_dir = lv_obj_get_base_dir(cont);
-    switch(type) {
-        case LV_LAYOUT_ROW_TOP:
-            vpad_corr = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_TOP_RIGHT : LV_ALIGN_IN_TOP_LEFT;
-            break;
-        case LV_LAYOUT_ROW_MID:
-            vpad_corr = 0;
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_RIGHT_MID : LV_ALIGN_IN_LEFT_MID;
-            break;
-        case LV_LAYOUT_ROW_BOTTOM:
-            vpad_corr = -lv_obj_get_style_pad_bottom(cont, LV_CONT_PART_MAIN);
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_BOTTOM_RIGHT : LV_ALIGN_IN_BOTTOM_LEFT;
-            break;
-        default:
-            vpad_corr = 0;
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_TOP_RIGHT : LV_ALIGN_IN_TOP_LEFT;
-            break;
-    }
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t last_cord;
-    if(base_dir == LV_BIDI_DIR_RTL) last_cord = lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    else last_cord = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-        if(base_dir == LV_BIDI_DIR_RTL) lv_obj_align(child, cont, align, -last_cord, vpad_corr);
-        else lv_obj_align(child, cont, align, last_cord, vpad_corr);
-
-        last_cord += lv_obj_get_width(child) + inner;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the center layout
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_center(lv_obj_t * cont)
-{
-    lv_obj_t * child;
-    uint32_t obj_num         = 0;
-    lv_coord_t h_tot         = 0;
-
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-    _LV_LL_READ(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        h_tot += lv_obj_get_height(child) + inner;
-        obj_num++;
-    }
-
-    if(obj_num == 0) return;
-
-    h_tot -= inner;
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t last_cord = -(h_tot / 2);
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-        lv_obj_align(child, cont, LV_ALIGN_CENTER, 0, last_cord + lv_obj_get_height(child) / 2);
-        last_cord += lv_obj_get_height(child) + inner;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the pretty layout. Put as many object as possible in row
- * then begin a new row
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_pretty(lv_obj_t * cont)
-{
-    lv_layout_t type = lv_cont_get_layout(cont);
-
-    lv_obj_t * child_rs;  /* Row starter child */
-    lv_obj_t * child_rc;  /* Row closer child */
-    lv_obj_t * child_tmp; /* Temporary child */
-    lv_coord_t w_obj         = lv_obj_get_width(cont);
-    lv_coord_t act_y         =  lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-
-    child_rs = _lv_ll_get_tail(&cont->child_ll); /*Set the row starter child*/
-    if(child_rs == NULL) return;                /*Return if no child*/
-
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-    lv_coord_t pleft          =  lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t pright         =  lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    lv_coord_t pinner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    child_rc = child_rs; /*Initially the the row starter and closer is the same*/
-    while(child_rs != NULL) {
-        lv_coord_t h_row = 0;
-        lv_coord_t w_row = pleft + pright; /*The width is at least the left+right pad*/
-        uint32_t obj_num = 0;
-
-        /*Find the row closer object and collect some data*/
-        do {
-            if(lv_obj_get_hidden(child_rc) == false && lv_obj_is_protected(child_rc, LV_PROTECT_POS) == false) {
-                /*If this object is already not fit then break*/
-                lv_coord_t w = lv_obj_get_width(child_rc);
-                w += lv_obj_get_style_margin_left(child_rc, LV_OBJ_PART_MAIN);
-                w += lv_obj_get_style_margin_right(child_rc, LV_OBJ_PART_MAIN);
-                if(w_row + w > w_obj) {
-                    /*Step back one child because the last already not fit, so the previous is the
-                     * closer*/
-                    if(child_rc != NULL && obj_num != 0) {
-                        child_rc = _lv_ll_get_next(&cont->child_ll, child_rc);
-                    }
-                    break;
-                }
-                w_row += w + pinner; /*Add the object width + inner padding*/
-
-                lv_coord_t h = lv_obj_get_height(child_rc);
-                h += lv_obj_get_style_margin_top(child_rc, LV_OBJ_PART_MAIN);
-                h += lv_obj_get_style_margin_bottom(child_rc, LV_OBJ_PART_MAIN);
-                h_row = LV_MATH_MAX(h_row, h);         /*Search the highest object*/
-                obj_num++;
-                if(lv_obj_is_protected(child_rc, LV_PROTECT_FOLLOW))
-                    break; /*If can not be followed by an other object then break here*/
-            }
-            child_rc = _lv_ll_get_prev(&cont->child_ll, child_rc); /*Load the next object*/
-            if(obj_num == 0)
-                child_rs = child_rc; /*If the first object was hidden (or too long) then set the
-                                        next as first */
-        } while(child_rc != NULL);
-
-        /*If the object is too long then align it to the middle*/
-        if(obj_num == 0) {
-            if(child_rc != NULL) {
-                lv_style_int_t mtop = lv_obj_get_style_margin_top(child_rc, LV_OBJ_PART_MAIN);
-
-                lv_obj_align(child_rc, cont, LV_ALIGN_IN_TOP_MID, 0, act_y + mtop);
-                h_row = lv_obj_get_height(child_rc); /*Not set previously because of the early break*/
-                h_row += mtop;
-                h_row += lv_obj_get_style_margin_bottom(child_rc, LV_OBJ_PART_MAIN);
-            }
-        }
-        /*If there is only one object in the row then align it to the middle*/
-        else if(obj_num == 1) {
-            lv_obj_align(child_rs, cont, LV_ALIGN_IN_TOP_MID,
-                         0,
-                         act_y + lv_obj_get_style_margin_top(child_rs, LV_OBJ_PART_MAIN));
-        }
-        /* Align the children (from child_rs to child_rc)*/
-        else {
-            w_row -= pinner * obj_num;
-            lv_coord_t new_pinner = (w_obj - w_row) / (obj_num - 1);
-            lv_coord_t act_x    = pleft; /*x init*/
-            child_tmp           = child_rs;
-            while(child_tmp != NULL) {
-                if(lv_obj_get_hidden(child_tmp) == false && lv_obj_is_protected(child_tmp, LV_PROTECT_POS) == false) {
-                    lv_coord_t mleft = lv_obj_get_style_margin_left(child_tmp, LV_OBJ_PART_MAIN);
-                    lv_coord_t mright = lv_obj_get_style_margin_right(child_tmp, LV_OBJ_PART_MAIN);
-                    switch(type) {
-                        case LV_LAYOUT_PRETTY_TOP:
-                            lv_obj_align(child_tmp, cont, LV_ALIGN_IN_TOP_LEFT,
-                                         act_x + mleft,
-                                         act_y + lv_obj_get_style_margin_top(child_tmp, LV_OBJ_PART_MAIN));
-                            break;
-                        case LV_LAYOUT_PRETTY_MID:
-                            lv_obj_align(child_tmp, cont, LV_ALIGN_IN_TOP_LEFT,
-                                         act_x + mleft,
-                                         act_y + (h_row - lv_obj_get_height(child_tmp)) / 2);
-
-                            break;
-                        case LV_LAYOUT_PRETTY_BOTTOM:
-                            lv_obj_align(child_tmp, cont, LV_ALIGN_IN_TOP_LEFT,
-                                         act_x + mleft,
-                                         act_y + h_row - lv_obj_get_height(child_tmp) - lv_obj_get_style_margin_bottom(child_tmp, LV_OBJ_PART_MAIN));
-                            break;
-                        default:
-                            break;
-                    }
-
-                    act_x += lv_obj_get_width(child_tmp) + new_pinner + mleft + mright;
-                }
-                if(child_tmp == child_rc) break;
-                child_tmp = _lv_ll_get_prev(&cont->child_ll, child_tmp);
-            }
-        }
-
-        if(child_rc == NULL) break;
-        act_y += pinner + h_row;           /*y increment*/
-        child_rs = _lv_ll_get_prev(&cont->child_ll, child_rc); /*Go to the next object*/
-        child_rc = child_rs;
-    }
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the grid layout. Align same-sized objects in a grid
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_grid(lv_obj_t * cont)
-{
-    lv_coord_t w_fit         =  lv_obj_get_width_fit(cont);
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-    lv_coord_t y_ofs = inner + lv_obj_get_height(lv_obj_get_child(cont, NULL));
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t left = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t act_x = left;
-    lv_coord_t act_y = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    lv_obj_t * child;
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        lv_coord_t obj_w = lv_obj_get_width(child);
-        if(act_x + obj_w > w_fit + left) {
-            act_x = left;
-            act_y += y_ofs;
-        }
-
-        lv_obj_set_pos(child, act_x, act_y);
-        act_x += inner + obj_w;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle auto fit. Set the size of the object to involve all children.
- * @param cont pointer to an object which size will be modified
- */
-static void lv_cont_refr_autofit(lv_obj_t * cont)
-{
-    if(lv_obj_is_protected(cont, LV_PROTECT_CHILD_CHG)) return;
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-
-    if(ext->fit_left == LV_FIT_NONE && ext->fit_right == LV_FIT_NONE && ext->fit_top == LV_FIT_NONE &&
-       ext->fit_bottom == LV_FIT_NONE) {
-        return;
-    }
-
-    lv_area_t tight_area;
-    lv_area_t ori;
-    lv_obj_t * child_i;
-
-    lv_obj_t * par               = lv_obj_get_parent(cont);
-    lv_area_t parent_area;
-    lv_area_copy(&parent_area, &par->coords);
-    parent_area.x1 += lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
-    parent_area.x2 -= lv_obj_get_style_pad_right(par, LV_OBJ_PART_MAIN);
-    parent_area.y1 += lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
-    parent_area.y2 -= lv_obj_get_style_pad_bottom(par, LV_OBJ_PART_MAIN);
-
-    /*Search the side coordinates of the children*/
-    lv_obj_get_coords(cont, &ori);
-    lv_obj_get_coords(cont, &tight_area);
-
-    bool has_children = _lv_ll_is_empty(&cont->child_ll) ? false : true;
-
-    if(has_children) {
-        tight_area.x1 = LV_COORD_MAX;
-        tight_area.y1 = LV_COORD_MAX;
-        tight_area.x2 = LV_COORD_MIN;
-        tight_area.y2 = LV_COORD_MIN;
-
-        _LV_LL_READ(cont->child_ll, child_i) {
-            if(lv_obj_get_hidden(child_i) != false) continue;
-
-            if(ext->fit_left != LV_FIT_PARENT) {
-                lv_style_int_t mleft = lv_obj_get_style_margin_left(child_i, LV_OBJ_PART_MAIN);
-                tight_area.x1 = LV_MATH_MIN(tight_area.x1, child_i->coords.x1 - mleft);
-            }
-
-            if(ext->fit_right != LV_FIT_PARENT) {
-                lv_style_int_t mright = lv_obj_get_style_margin_right(child_i, LV_OBJ_PART_MAIN);
-                tight_area.x2 = LV_MATH_MAX(tight_area.x2, child_i->coords.x2 + mright);
-            }
-
-            if(ext->fit_top != LV_FIT_PARENT) {
-                lv_style_int_t mtop = lv_obj_get_style_margin_top(child_i, LV_OBJ_PART_MAIN);
-                tight_area.y1 = LV_MATH_MIN(tight_area.y1, child_i->coords.y1 - mtop);
-            }
-
-            if(ext->fit_bottom != LV_FIT_PARENT) {
-                lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(child_i, LV_OBJ_PART_MAIN);
-                tight_area.y2 = LV_MATH_MAX(tight_area.y2, child_i->coords.y2 + mbottom);
-            }
-        }
-
-        tight_area.x1 -= lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-        tight_area.x2 += lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-        tight_area.y1 -= lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-        tight_area.y2 += lv_obj_get_style_pad_bottom(cont, LV_CONT_PART_MAIN);
-    }
-
-    lv_area_t new_area;
-    lv_area_copy(&new_area, &ori);
-
-    switch(ext->fit_left) {
-        case LV_FIT_TIGHT:
-            new_area.x1 = tight_area.x1;
-            break;
-        case LV_FIT_PARENT:
-            new_area.x1 = parent_area.x1;
-            break;
-        case LV_FIT_MAX:
-            new_area.x1 = has_children ? LV_MATH_MIN(tight_area.x1, parent_area.x1) : parent_area.x1;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_right) {
-        case LV_FIT_TIGHT:
-            new_area.x2 = tight_area.x2;
-            break;
-        case LV_FIT_PARENT:
-            new_area.x2 = parent_area.x2;
-            break;
-        case LV_FIT_MAX:
-            new_area.x2 = has_children ? LV_MATH_MAX(tight_area.x2, parent_area.x2) : parent_area.x2;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_top) {
-        case LV_FIT_TIGHT:
-            new_area.y1 = tight_area.y1;
-            break;
-        case LV_FIT_PARENT:
-            new_area.y1 = parent_area.y1;
-            break;
-        case LV_FIT_MAX:
-            new_area.y1 = has_children ? LV_MATH_MIN(tight_area.y1, parent_area.y1) : parent_area.y1;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_bottom) {
-        case LV_FIT_TIGHT:
-            new_area.y2 = tight_area.y2;
-            break;
-        case LV_FIT_PARENT:
-            new_area.y2 = parent_area.y2;
-            break;
-        case LV_FIT_MAX:
-            new_area.y2 = has_children ? LV_MATH_MAX(tight_area.y2, parent_area.y2) : parent_area.y2;
-            break;
-        default:
-            break;
-    }
-
-    /*Do nothing if the coordinates are not changed*/
-    if(cont->coords.x1 != new_area.x1 || cont->coords.y1 != new_area.y1 || cont->coords.x2 != new_area.x2 ||
-       cont->coords.y2 != new_area.y2) {
-
-        lv_obj_invalidate(cont);
-        lv_area_copy(&cont->coords, &new_area);
-        lv_obj_invalidate(cont);
-
-        /*Notify the object about its new coordinates*/
-        cont->signal_cb(cont, LV_SIGNAL_COORD_CHG, &ori);
-
-        /*Inform the parent about the new coordinates*/
-        par->signal_cb(par, LV_SIGNAL_CHILD_CHG, cont);
-
-        if(lv_obj_get_auto_realign(cont)) {
-            lv_obj_realign(cont);
-        }
-
-        /*Tell the children the parent's size has changed*/
-        _LV_LL_READ(cont->child_ll, child_i) {
-            child_i->signal_cb(child_i, LV_SIGNAL_PARENT_SIZE_CHG, &ori);
-        }
-    }
-}
-
-#endif
diff --git a/src/lv_widgets/lv_cont.h b/src/lv_widgets/lv_cont.h
deleted file mode 100644
index 837559a3d..000000000
--- a/src/lv_widgets/lv_cont.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/**
- * @file lv_cont.h
- *
- */
-
-#ifndef LV_CONT_H
-#define LV_CONT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_CONT != 0
-
-#include "../lv_core/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/** Container layout options*/
-enum {
-    LV_LAYOUT_OFF = 0, /**< No layout */
-    LV_LAYOUT_CENTER, /**< Center objects */
-
-    /**
-     * COULMN:
-     * - Place the object below each other
-     * - Keep `pad_top` space on the top
-     * - Keep `pad_inner` space between the objects
-     */
-    LV_LAYOUT_COLUMN_LEFT,      /**< Column left align*/
-    LV_LAYOUT_COLUMN_MID,       /**< Column middle align*/
-    LV_LAYOUT_COLUMN_RIGHT,     /**< Column right align*/
-
-    /**
-     * ROW:
-     * - Place the object next to each other
-     * - Keep `pad_left` space on the left
-     * - Keep `pad_inner` space between the objects
-     * - If the object which applies the layout has `base_dir == LV_BIDI_DIR_RTL`
-     *   the row will start from the right applying `pad.right` space
-     */
-    LV_LAYOUT_ROW_TOP,          /**< Row top align*/
-    LV_LAYOUT_ROW_MID,          /**< Row middle align*/
-    LV_LAYOUT_ROW_BOTTOM,       /**< Row bottom align*/
-
-
-    /**
-     * PRETTY:
-     * - Place the object next to each other
-     * - If there is no more space start a new row
-     * - Respect `pad_left` and `pad_right` when determining the available space in a row
-     * - Keep `pad_inner` space between the objects in the same row
-     * - Keep `pad_inner` space between the objects in rows
-     * - Divide the remaining horizontal space equally
-     */
-    LV_LAYOUT_PRETTY_TOP,       /**< Row top align*/
-    LV_LAYOUT_PRETTY_MID,       /**< Row middle align*/
-    LV_LAYOUT_PRETTY_BOTTOM,    /**< Row bottom align*/
-
-    /**
-     * GRID
-     * - Place the object next to each other
-     * - If there is no more space start a new row
-     * - Respect `pad_left` and `pad_right` when determining the available space in a row
-     * - Keep `pad_inner` space between the objects in the same row
-     * - Keep `pad_inner` space between the objects in rows
-     * - Unlike `PRETTY`, `GRID` always keep `pad_inner` space horizontally between objects
-     *   so it doesn't divide the remaining horizontal space equally
-     */
-    LV_LAYOUT_GRID,   /**< Align same-sized object into a grid*/
-
-    _LV_LAYOUT_LAST
-};
-typedef uint8_t lv_layout_t;
-
-/**
- * How to resize the container around the children.
- */
-enum {
-    LV_FIT_NONE,  /**< Do not change the size automatically*/
-    LV_FIT_TIGHT, /**< Shrink wrap around the children */
-    LV_FIT_PARENT, /**< Align the size to the parent's edge*/
-    LV_FIT_MAX,  /**< Align the size to the parent's edge first but if there is an object out of it
-                     then get larger */
-    _LV_FIT_LAST
-};
-typedef uint8_t lv_fit_t;
-
-typedef struct {
-    /*Inherited from 'base_obj' so no inherited ext. */ /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_layout_t layout : 4;     /*A layout from 'lv_layout_t' enum*/
-    lv_fit_t fit_left : 2;   /*A fit type from `lv_fit_t` enum */
-    lv_fit_t fit_right : 2;  /*A fit type from `lv_fit_t` enum */
-    lv_fit_t fit_top : 2;    /*A fit type from `lv_fit_t` enum */
-    lv_fit_t fit_bottom : 2; /*A fit type from `lv_fit_t` enum */
-} lv_cont_ext_t;
-
-/*Part of the container*/
-enum {
-    LV_CONT_PART_MAIN = LV_OBJ_PART_MAIN,
-    _LV_CONT_PART_VIRTUAL_LAST = _LV_OBJ_PART_VIRTUAL_LAST,
-    _LV_CONT_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
-};
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a container objects
- * @param par pointer to an object, it will be the parent of the new container
- * @param copy pointer to a container object, if not NULL then the new object will be copied from it
- * @return pointer to the created container
- */
-lv_obj_t * lv_cont_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a layout on a container
- * @param cont pointer to a container object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout);
-
-/**
- * Set the fit policy in all 4 directions separately.
- * It tell how to change the container's size automatically.
- * @param cont pointer to a container object
- * @param left left fit policy from `lv_fit_t`
- * @param right right fit policy from `lv_fit_t`
- * @param top top fit policy from `lv_fit_t`
- * @param bottom bottom fit policy from `lv_fit_t`
- */
-void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom);
-
-/**
- * Set the fit policy horizontally and vertically separately.
- * It tells how to change the container's size automatically.
- * @param cont pointer to a container object
- * @param hor horizontal fit policy from `lv_fit_t`
- * @param ver vertical fit policy from `lv_fit_t`
- */
-static inline void lv_cont_set_fit2(lv_obj_t * cont, lv_fit_t hor, lv_fit_t ver)
-{
-    lv_cont_set_fit4(cont, hor, hor, ver, ver);
-}
-
-/**
- * Set the fit policy in all 4 direction at once.
- * It tells how to change the container's size automatically.
- * @param cont pointer to a container object
- * @param fit fit policy from `lv_fit_t`
- */
-static inline void lv_cont_set_fit(lv_obj_t * cont, lv_fit_t fit)
-{
-    lv_cont_set_fit4(cont, fit, fit, fit, fit);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the layout of a container
- * @param cont pointer to container object
- * @return the layout from 'lv_cont_layout_t'
- */
-lv_layout_t lv_cont_get_layout(const lv_obj_t * cont);
-
-/**
- * Get left fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_left(const lv_obj_t * cont);
-
-/**
- * Get right fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_right(const lv_obj_t * cont);
-
-/**
- * Get top fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_top(const lv_obj_t * cont);
-
-/**
- * Get bottom fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_bottom(const lv_obj_t * cont);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_CONT*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_CONT_H*/
diff --git a/src/lv_widgets/lv_cpicker.c b/src/lv_widgets/lv_cpicker.c
deleted file mode 100644
index 9b3a857ae..000000000
--- a/src/lv_widgets/lv_cpicker.c
+++ /dev/null
@@ -1,1039 +0,0 @@
-/**
- * @file lv_cpicker.c
- *
- * From @AloyseTech and @paulpv.
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_cpicker.h"
-#if LV_USE_CPICKER != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw_arc.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_core/lv_indev.h"
-#include "../lv_core/lv_refr.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_cpicker"
-
-#ifndef LV_CPICKER_DEF_TYPE
-    #define LV_CPICKER_DEF_TYPE LV_CPICKER_TYPE_DISC
-#endif
-
-#ifndef LV_CPICKER_DEF_HUE
-    #define LV_CPICKER_DEF_HUE 0
-#endif
-
-#ifndef LV_CPICKER_DEF_SATURATION
-    #define LV_CPICKER_DEF_SATURATION 100
-#endif
-
-#ifndef LV_CPICKER_DEF_VALUE
-    #define LV_CPICKER_DEF_VALUE 100
-#endif
-
-#ifndef LV_CPICKER_DEF_HSV
-    #define LV_CPICKER_DEF_HSV ((lv_color_hsv_t){LV_CPICKER_DEF_HUE, LV_CPICKER_DEF_SATURATION, LV_CPICKER_DEF_VALUE})
-#endif
-
-#ifndef LV_CPICKER_DEF_QF /*quantization factor*/
-    #define LV_CPICKER_DEF_QF 3
-#endif
-
-#define TRI_OFFSET 2
-
-/* The OUTER_MASK_WIDTH define is required to assist with the placing of a mask over the outer ring of the widget as when the
- * multicoloured radial lines are calculated for the outer ring of the widget their lengths are jittering because of the
- * integer based arithmetic. From tests the maximum delta was found to be 2 so the current value is set to 3 to achieve
- * appropriate masking.
- */
-#define OUTER_MASK_WIDTH 3
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_design_res_t lv_cpicker_design(lv_obj_t * cpicker, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_cpicker_signal(lv_obj_t * cpicker, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_cpicker_get_style(lv_obj_t * cpicker, uint8_t part);
-static bool lv_cpicker_hit(lv_obj_t * cpicker, const lv_point_t * p);
-
-static void draw_rect_grad(lv_obj_t * cpicker, const lv_area_t * mask);
-static void draw_disc_grad(lv_obj_t * cpicker, const lv_area_t * mask);
-static void draw_knob(lv_obj_t * cpicker, const lv_area_t * mask);
-static void invalidate_knob(lv_obj_t * cpicker);
-static lv_area_t get_knob_area(lv_obj_t * cpicker);
-
-static void next_color_mode(lv_obj_t * cpicker);
-static lv_res_t double_click_reset(lv_obj_t * cpicker);
-static void refr_knob_pos(lv_obj_t * cpicker);
-static lv_color_t angle_to_mode_color(lv_obj_t * cpicker, uint16_t angle);
-static uint16_t get_angle(lv_obj_t * cpicker);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a color_picker object
- * @param par pointer to an object, it will be the parent of the new color_picker
- * @param copy pointer to a color_picker object, if not NULL then the new object will be copied from it
- * @return pointer to the created color_picker
- */
-lv_obj_t * lv_cpicker_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("color_picker create started");
-
-    lv_obj_t * cpicker = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(cpicker);
-    if(cpicker == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(cpicker);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(cpicker);
-
-    /*Allocate the extended data*/
-    lv_cpicker_ext_t * ext = lv_obj_allocate_ext_attr(cpicker, sizeof(lv_cpicker_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(cpicker);
-        return NULL;
-    }
-
-    /*Initialize the allocated 'ext' */
-    ext->type = LV_CPICKER_DEF_TYPE;
-    ext->hsv = LV_CPICKER_DEF_HSV;
-    ext->knob.colored = 1;
-    ext->color_mode = LV_CPICKER_COLOR_MODE_HUE;
-    ext->color_mode_fixed = 0;
-    ext->last_click_time = 0;
-    ext->last_change_time = 0;
-
-    lv_style_list_init(&ext->knob.style_list);
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(cpicker, lv_cpicker_signal);
-    lv_obj_set_design_cb(cpicker, lv_cpicker_design);
-
-    /*If no copy do the basic initialization*/
-    if(copy == NULL) {
-        lv_obj_set_size(cpicker, LV_DPI * 2, LV_DPI * 2);
-        lv_obj_add_protect(cpicker, LV_PROTECT_PRESS_LOST);
-        lv_obj_set_adv_hittest(cpicker, true);
-        lv_theme_apply(cpicker, LV_THEME_CPICKER);
-    }
-    /*Copy 'copy'*/
-    else {
-        lv_cpicker_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->type = copy_ext->type;
-        ext->color_mode = copy_ext->color_mode;
-        ext->color_mode_fixed = copy_ext->color_mode_fixed;
-        ext->hsv = copy_ext->hsv;
-        ext->knob.colored = copy_ext->knob.colored;
-
-        lv_style_list_copy(&ext->knob.style_list, &copy_ext->knob.style_list);
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(cpicker, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-    refr_knob_pos(cpicker);
-
-    LV_LOG_INFO("color_picker created");
-
-    return cpicker;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new type for a cpicker
- * @param cpicker pointer to a cpicker object
- * @param type new type of the cpicker (from 'lv_cpicker_type_t' enum)
- */
-void lv_cpicker_set_type(lv_obj_t * cpicker, lv_cpicker_type_t type)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    if(ext->type == type) return;
-
-    ext->type = type;
-    lv_obj_refresh_ext_draw_pad(cpicker);
-    refr_knob_pos(cpicker);
-
-    lv_obj_invalidate(cpicker);
-}
-
-/**
- * Set the current hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param hue current selected hue [0..360]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_hue(lv_obj_t * cpicker, uint16_t hue)
-{
-    lv_color_hsv_t hsv = lv_cpicker_get_hsv(cpicker);
-    hsv.h = hue;
-    return lv_cpicker_set_hsv(cpicker, hsv);
-}
-
-/**
- * Set the current saturation of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param saturation current selected saturation [0..100]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_saturation(lv_obj_t * cpicker, uint8_t saturation)
-{
-    lv_color_hsv_t hsv = lv_cpicker_get_hsv(cpicker);
-    hsv.s = saturation;
-    return lv_cpicker_set_hsv(cpicker, hsv);
-}
-
-/**
- * Set the current value of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param val current selected value [0..100]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_value(lv_obj_t * cpicker, uint8_t val)
-{
-    lv_color_hsv_t hsv = lv_cpicker_get_hsv(cpicker);
-    hsv.v = val;
-    return lv_cpicker_set_hsv(cpicker, hsv);
-}
-
-/**
- * Set the current hsv of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param color current selected hsv
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_hsv(lv_obj_t * cpicker, lv_color_hsv_t hsv)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    if(hsv.h > 360) hsv.h %= 360;
-    if(hsv.s > 100) hsv.s = 100;
-    if(hsv.v > 100) hsv.v = 100;
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    if(ext->hsv.h == hsv.h && ext->hsv.s == hsv.s && ext->hsv.v == hsv.v) return false;
-
-    ext->hsv = hsv;
-
-    refr_knob_pos(cpicker);
-
-    lv_obj_invalidate(cpicker);
-
-    return true;
-}
-
-/**
- * Set the current color of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param color current selected color
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_color(lv_obj_t * cpicker, lv_color_t color)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_color32_t c32;
-    c32.full = lv_color_to32(color);
-
-    return lv_cpicker_set_hsv(cpicker,
-                              lv_color_rgb_to_hsv(c32.ch.red, c32.ch.green, c32.ch.blue));
-}
-
-/**
- * Set the current color mode.
- * @param cpicker pointer to colorpicker object
- * @param mode color mode (hue/sat/val)
- */
-void lv_cpicker_set_color_mode(lv_obj_t * cpicker, lv_cpicker_color_mode_t mode)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    ext->color_mode = mode;
-    refr_knob_pos(cpicker);
-    lv_obj_invalidate(cpicker);
-}
-
-/**
- * Set if the color mode is changed on long press on center
- * @param cpicker pointer to colorpicker object
- * @param fixed color mode cannot be changed on long press
- */
-void lv_cpicker_set_color_mode_fixed(lv_obj_t * cpicker, bool fixed)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    ext->color_mode_fixed = fixed;
-}
-
-/**
- * Make the knob to be colored to the current color
- * @param cpicker pointer to colorpicker object
- * @param en true: color the knob; false: not color the knob
- */
-void lv_cpicker_set_knob_colored(lv_obj_t * cpicker, bool en)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    ext->knob.colored = en ? 1 : 0;
-    invalidate_knob(cpicker);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the current color mode.
- * @param cpicker pointer to colorpicker object
- * @return color mode (hue/sat/val)
- */
-lv_cpicker_color_mode_t lv_cpicker_get_color_mode(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->color_mode;
-}
-
-/**
- * Get if the color mode is changed on long press on center
- * @param cpicker pointer to colorpicker object
- * @return mode cannot be changed on long press
- */
-bool lv_cpicker_get_color_mode_fixed(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->color_mode_fixed;
-}
-
-/**
- * Get the current selected hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return hue current selected hue
- */
-uint16_t lv_cpicker_get_hue(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->hsv.h;
-}
-
-/**
- * Get the current selected saturation of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected saturation
- */
-uint8_t lv_cpicker_get_saturation(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->hsv.s;
-}
-
-/**
- * Get the current selected hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected value
- */
-uint8_t lv_cpicker_get_value(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->hsv.v;
-}
-
-/**
- * Get the current selected hsv of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected hsv
- */
-lv_color_hsv_t lv_cpicker_get_hsv(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->hsv;
-}
-
-/**
- * Get the current selected color of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return color current selected color
- */
-lv_color_t lv_cpicker_get_color(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return lv_color_hsv_to_rgb(ext->hsv.h, ext->hsv.s, ext->hsv.v);
-}
-
-/**
- * Whether the knob is colored to the current color or not
- * @param cpicker pointer to color picker object
- * @return true: color the knob; false: not color the knob
- */
-bool lv_cpicker_get_knob_colored(lv_obj_t * cpicker)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    return ext->knob.colored ? true : false;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-
-/**
- * Handle the drawing related tasks of the color_picker
- * @param cpicker pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @return return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_cpicker_design(lv_obj_t * cpicker, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK)  {
-        return LV_DESIGN_RES_NOT_COVER;
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-        if(ext->type == LV_CPICKER_TYPE_DISC) {
-            draw_disc_grad(cpicker, clip_area);
-        }
-        else if(ext->type == LV_CPICKER_TYPE_RECT) {
-            draw_rect_grad(cpicker, clip_area);
-        }
-
-        draw_knob(cpicker, clip_area);
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
-static void draw_disc_grad(lv_obj_t * cpicker, const lv_area_t * mask)
-{
-    lv_coord_t w = lv_obj_get_width(cpicker);
-    lv_coord_t h = lv_obj_get_height(cpicker);
-    lv_coord_t cx = cpicker->coords.x1 + w / 2;
-    lv_coord_t cy = cpicker->coords.y1 + h / 2;
-    lv_coord_t r = w / 2;
-
-    lv_draw_line_dsc_t line_dsc;
-    lv_draw_line_dsc_init(&line_dsc);
-    lv_obj_init_draw_line_dsc(cpicker, LV_CPICKER_PART_MAIN, &line_dsc);
-
-    line_dsc.width = (r * 628 / (360 / LV_CPICKER_DEF_QF)) / 100;
-    line_dsc.width += 2;
-    uint16_t i;
-    lv_coord_t cir_w = lv_obj_get_style_scale_width(cpicker, LV_CPICKER_PART_MAIN);
-
-    /* Mask outer ring of widget to tidy up ragged edges of lines while drawing outer ring */
-    lv_area_t mask_area_out;
-    lv_area_copy(&mask_area_out, &cpicker->coords);
-    mask_area_out.x1 += OUTER_MASK_WIDTH;
-    mask_area_out.x2 -= OUTER_MASK_WIDTH;
-    mask_area_out.y1 += OUTER_MASK_WIDTH;
-    mask_area_out.y2 -= OUTER_MASK_WIDTH;
-    lv_draw_mask_radius_param_t mask_out_param;
-    lv_draw_mask_radius_init(&mask_out_param, &mask_area_out, LV_RADIUS_CIRCLE, false);
-    int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, 0);
-
-    /* The inner line ends will be masked out.
-     * So make lines a little bit longer because the masking makes a more even result */
-    lv_coord_t cir_w_extra = cir_w + line_dsc.width;
-
-    for(i = 0; i <= 360; i += LV_CPICKER_DEF_QF) {
-        line_dsc.color = angle_to_mode_color(cpicker, i);
-
-        lv_point_t p[2];
-        p[0].x = cx + (r * _lv_trigo_sin(i) >> LV_TRIGO_SHIFT);
-        p[0].y = cy + (r * _lv_trigo_sin(i + 90) >> LV_TRIGO_SHIFT);
-        p[1].x = cx + ((r - cir_w_extra) * _lv_trigo_sin(i) >> LV_TRIGO_SHIFT);
-        p[1].y = cy + ((r - cir_w_extra) * _lv_trigo_sin(i + 90) >> LV_TRIGO_SHIFT);
-
-        lv_draw_line(&p[0], &p[1], mask, &line_dsc);
-    }
-    /* Now remove mask to continue with inner part */
-    lv_draw_mask_remove_id(mask_out_id);
-
-    /*Mask out the inner area*/
-    lv_draw_rect_dsc_t bg_dsc;
-    lv_draw_rect_dsc_init(&bg_dsc);
-    lv_obj_init_draw_rect_dsc(cpicker, LV_CPICKER_PART_MAIN, &bg_dsc);
-    bg_dsc.radius = LV_RADIUS_CIRCLE;
-
-    lv_area_t area_mid;
-    lv_area_copy(&area_mid, &cpicker->coords);
-    area_mid.x1 += cir_w;
-    area_mid.y1 += cir_w;
-    area_mid.x2 -= cir_w;
-    area_mid.y2 -= cir_w;
-
-    lv_draw_rect(&area_mid, mask, &bg_dsc);
-
-    lv_style_int_t inner = lv_obj_get_style_pad_inner(cpicker, LV_CPICKER_PART_MAIN);
-    lv_color_t color = lv_cpicker_get_color(cpicker);
-    bg_dsc.bg_color = color;
-    area_mid.x1 += inner;
-    area_mid.y1 += inner;
-    area_mid.x2 -= inner;
-    area_mid.y2 -= inner;
-
-    lv_draw_rect(&area_mid, mask, &bg_dsc);
-}
-
-static void draw_rect_grad(lv_obj_t * cpicker, const lv_area_t * mask)
-{
-    lv_draw_rect_dsc_t bg_dsc;
-    lv_draw_rect_dsc_init(&bg_dsc);
-    lv_obj_init_draw_rect_dsc(cpicker, LV_CPICKER_PART_MAIN, &bg_dsc);
-
-    lv_area_t grad_area;
-    lv_obj_get_coords(cpicker, &grad_area);
-
-    if(bg_dsc.radius) {
-        lv_coord_t h = lv_obj_get_height(cpicker);
-        lv_coord_t r = bg_dsc.radius;
-        if(r > h / 2) r = h / 2;
-        /*Make the gradient area smaller with a half circle on both ends*/
-        grad_area.x1 += r;
-        grad_area.x2 -= r;
-
-        /*Draw the left rounded end*/
-        lv_area_t rounded_edge_area;
-        lv_obj_get_coords(cpicker, &rounded_edge_area);
-        rounded_edge_area.x2 = rounded_edge_area.x1 + 2 * r;
-
-        bg_dsc.bg_color = angle_to_mode_color(cpicker, 0);
-
-        lv_draw_rect(&rounded_edge_area, mask, &bg_dsc);
-
-        /*Draw the right rounded end*/
-        lv_obj_get_coords(cpicker, &rounded_edge_area);
-        rounded_edge_area.x1 = rounded_edge_area.x2 - 2 * r;
-
-        bg_dsc.bg_color = angle_to_mode_color(cpicker, 359);
-
-        lv_draw_rect(&rounded_edge_area, mask, &bg_dsc);
-    }
-
-    lv_coord_t grad_w = lv_area_get_width(&grad_area);
-    uint16_t i_step = LV_MATH_MAX(LV_CPICKER_DEF_QF, 360 / grad_w);
-    bg_dsc.radius = 0;
-    bg_dsc.border_width = 0;
-    bg_dsc.shadow_width = 0;
-
-    uint16_t i;
-    for(i = 0; i < 360; i += i_step) {
-        bg_dsc.bg_color = angle_to_mode_color(cpicker, i);
-
-        /*the following attribute might need changing between index to add border, shadow, radius etc*/
-        lv_area_t rect_area;
-
-        /*scale angle (hue/sat/val) to linear coordinate*/
-        lv_coord_t xi = (i * grad_w) / 360;
-        lv_coord_t xi2 = ((i + i_step) * grad_w) / 360;
-
-        rect_area.x1 = LV_MATH_MIN(grad_area.x1 + xi, grad_area.x1 + grad_w - i_step);
-        rect_area.y1 = grad_area.y1;
-        rect_area.x2 = LV_MATH_MIN(grad_area.x1 + xi2, grad_area.x1 + grad_w - i_step);
-        rect_area.y2 = grad_area.y2;
-
-        lv_draw_rect(&rect_area, mask, &bg_dsc);
-    }
-}
-
-static void draw_knob(lv_obj_t * cpicker, const lv_area_t * mask)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    lv_draw_rect_dsc_t cir_dsc;
-    lv_draw_rect_dsc_init(&cir_dsc);
-    lv_obj_init_draw_rect_dsc(cpicker, LV_CPICKER_PART_KNOB, &cir_dsc);
-
-    cir_dsc.radius = LV_RADIUS_CIRCLE;
-
-    if(ext->knob.colored) {
-        cir_dsc.bg_color = lv_cpicker_get_color(cpicker);
-    }
-
-    lv_area_t knob_area = get_knob_area(cpicker);
-
-    lv_draw_rect(&knob_area, mask, &cir_dsc);
-}
-
-static void invalidate_knob(lv_obj_t * cpicker)
-{
-    lv_area_t knob_area = get_knob_area(cpicker);
-
-    lv_obj_invalidate_area(cpicker, &knob_area);
-}
-
-static lv_area_t get_knob_area(lv_obj_t * cpicker)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    /*Get knob's radius*/
-    uint16_t r = 0;
-    if(ext->type == LV_CPICKER_TYPE_DISC) {
-        r = lv_obj_get_style_scale_width(cpicker, LV_CPICKER_PART_MAIN) / 2;
-    }
-    else if(ext->type == LV_CPICKER_TYPE_RECT) {
-        lv_coord_t h = lv_obj_get_height(cpicker);
-        r = h / 2;
-    }
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(cpicker, LV_CPICKER_PART_KNOB);
-    lv_style_int_t right = lv_obj_get_style_pad_right(cpicker, LV_CPICKER_PART_KNOB);
-    lv_style_int_t top = lv_obj_get_style_pad_top(cpicker, LV_CPICKER_PART_KNOB);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(cpicker, LV_CPICKER_PART_KNOB);
-
-    lv_area_t knob_area;
-    knob_area.x1 = cpicker->coords.x1 + ext->knob.pos.x - r - left;
-    knob_area.y1 = cpicker->coords.y1 + ext->knob.pos.y - r - right;
-    knob_area.x2 = cpicker->coords.x1 + ext->knob.pos.x + r + top;
-    knob_area.y2 = cpicker->coords.y1 + ext->knob.pos.y + r + bottom;
-
-    return knob_area;
-}
-
-/**
- * Signal function of the color_picker
- * @param cpicker pointer to a color_picker object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_cpicker_signal(lv_obj_t * cpicker, lv_signal_t sign, void * param)
-{
-    /* Include the ancient signal function */
-    lv_res_t res;
-
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_cpicker_get_style(cpicker, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(cpicker, sign, param);
-    }
-
-    res = ancestor_signal(cpicker, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(cpicker, LV_CPICKER_PART_KNOB);
-    }
-    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        lv_style_int_t left = lv_obj_get_style_pad_left(cpicker, LV_CPICKER_PART_KNOB);
-        lv_style_int_t right = lv_obj_get_style_pad_right(cpicker, LV_CPICKER_PART_KNOB);
-        lv_style_int_t top = lv_obj_get_style_pad_top(cpicker, LV_CPICKER_PART_KNOB);
-        lv_style_int_t bottom = lv_obj_get_style_pad_bottom(cpicker, LV_CPICKER_PART_KNOB);
-
-        lv_coord_t knob_pad = LV_MATH_MAX4(left, right, top, bottom) + 2;
-
-        if(ext->type == LV_CPICKER_TYPE_DISC) {
-            cpicker->ext_draw_pad = LV_MATH_MAX(cpicker->ext_draw_pad, knob_pad);
-        }
-        else {
-            knob_pad += lv_obj_get_height(cpicker) / 2;
-            cpicker->ext_draw_pad = LV_MATH_MAX(cpicker->ext_draw_pad, knob_pad);
-        }
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        /*Refresh extended draw area to make knob visible*/
-        if(lv_obj_get_width(cpicker) != lv_area_get_width(param) ||
-           lv_obj_get_height(cpicker) != lv_area_get_height(param)) {
-            lv_obj_refresh_ext_draw_pad(cpicker);
-            refr_knob_pos(cpicker);
-            lv_obj_invalidate(cpicker);
-        }
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        /*Refresh extended draw area to make knob visible*/
-        lv_obj_refresh_ext_draw_pad(cpicker);
-        refr_knob_pos(cpicker);
-        lv_obj_invalidate(cpicker);
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        uint32_t c = *((uint32_t *)param); /*uint32_t because can be UTF-8*/
-
-        if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
-            lv_color_hsv_t hsv_cur;
-            hsv_cur = ext->hsv;
-
-            switch(ext->color_mode) {
-                case LV_CPICKER_COLOR_MODE_HUE:
-                    hsv_cur.h = (ext->hsv.h + 1) % 360;
-                    break;
-                case LV_CPICKER_COLOR_MODE_SATURATION:
-                    hsv_cur.s = (ext->hsv.s + 1) % 100;
-                    break;
-                case LV_CPICKER_COLOR_MODE_VALUE:
-                    hsv_cur.v = (ext->hsv.v + 1) % 100;
-                    break;
-            }
-
-            if(lv_cpicker_set_hsv(cpicker, hsv_cur)) {
-                res = lv_event_send(cpicker, LV_EVENT_VALUE_CHANGED, NULL);
-                if(res != LV_RES_OK) return res;
-            }
-        }
-        else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
-            lv_color_hsv_t hsv_cur;
-            hsv_cur = ext->hsv;
-
-            switch(ext->color_mode) {
-                case LV_CPICKER_COLOR_MODE_HUE:
-                    hsv_cur.h = ext->hsv.h > 0 ? (ext->hsv.h - 1) : 360;
-                    break;
-                case LV_CPICKER_COLOR_MODE_SATURATION:
-                    hsv_cur.s = ext->hsv.s > 0 ? (ext->hsv.s - 1) : 100;
-                    break;
-                case LV_CPICKER_COLOR_MODE_VALUE:
-                    hsv_cur.v = ext->hsv.v > 0 ? (ext->hsv.v - 1) : 100;
-                    break;
-            }
-
-            if(lv_cpicker_set_hsv(cpicker, hsv_cur)) {
-                res = lv_event_send(cpicker, LV_EVENT_VALUE_CHANGED, NULL);
-                if(res != LV_RES_OK) return res;
-            }
-        }
-#endif
-    }
-    else if(sign == LV_SIGNAL_PRESSED) {
-        ext->last_change_time = lv_tick_get();
-        lv_indev_get_point(lv_indev_get_act(), &ext->last_press_point);
-        res = double_click_reset(cpicker);
-        if(res != LV_RES_OK) return res;
-    }
-    else if(sign == LV_SIGNAL_PRESSING) {
-        lv_indev_t * indev = lv_indev_get_act();
-        if(indev == NULL) return res;
-
-        lv_indev_type_t indev_type = lv_indev_get_type(indev);
-        lv_point_t p;
-        if(indev_type == LV_INDEV_TYPE_ENCODER || indev_type == LV_INDEV_TYPE_KEYPAD) {
-            p.x = cpicker->coords.x1 + lv_obj_get_width(cpicker) / 2;
-            p.y = cpicker->coords.y1 + lv_obj_get_height(cpicker) / 2;
-        }
-        else {
-            lv_indev_get_point(indev, &p);
-        }
-
-        if((LV_MATH_ABS(p.x - ext->last_press_point.x) > indev->driver.scroll_limit / 2) ||
-           (LV_MATH_ABS(p.y - ext->last_press_point.y) > indev->driver.scroll_limit / 2)) {
-            ext->last_change_time = lv_tick_get();
-            ext->last_press_point.x = p.x;
-            ext->last_press_point.y = p.y;
-        }
-
-        p.x -= cpicker->coords.x1;
-        p.y -= cpicker->coords.y1;
-
-        /*Ignore pressing in the inner area*/
-        uint16_t w = lv_obj_get_width(cpicker);
-
-        int16_t angle = 0;
-
-        if(ext->type == LV_CPICKER_TYPE_RECT) {
-            /*If pressed long enough without change go to next color mode*/
-            uint32_t diff = lv_tick_elaps(ext->last_change_time);
-            if(diff > (uint32_t)indev->driver.long_press_time * 2 && !ext->color_mode_fixed) {
-                next_color_mode(cpicker);
-                lv_indev_wait_release(lv_indev_get_act());
-                return res;
-            }
-
-            angle = (p.x * 360) / w;
-            if(angle < 0) angle = 0;
-            if(angle >= 360) angle = 359;
-
-        }
-        else if(ext->type == LV_CPICKER_TYPE_DISC) {
-            lv_style_int_t scale_w = lv_obj_get_style_scale_width(cpicker, LV_CPICKER_PART_MAIN);
-
-            lv_coord_t r_in = w / 2;
-            p.x -= r_in;
-            p.y -= r_in;
-            bool on_ring = true;
-            r_in -= scale_w;
-            if(r_in > LV_DPI / 2) {
-                lv_style_int_t inner = lv_obj_get_style_pad_inner(cpicker, LV_CPICKER_PART_MAIN);
-                r_in -= inner;
-
-                if(r_in < LV_DPI / 2) r_in = LV_DPI / 2;
-            }
-
-            if(p.x * p.x + p.y * p.y < r_in * r_in) {
-                on_ring = false;
-            }
-
-            /*If the inner area is being pressed, go to the next color mode on long press*/
-            uint32_t diff = lv_tick_elaps(ext->last_change_time);
-            if(!on_ring && diff > indev->driver.long_press_time && !ext->color_mode_fixed) {
-                next_color_mode(cpicker);
-                lv_indev_wait_release(lv_indev_get_act());
-                return res;
-            }
-
-            /*Set the angle only if pressed on the ring*/
-            if(!on_ring) return res;
-
-            angle = _lv_atan2(p.x, p.y) % 360;
-        }
-
-        lv_color_hsv_t hsv_cur;
-        hsv_cur = ext->hsv;
-
-        switch(ext->color_mode) {
-            case LV_CPICKER_COLOR_MODE_HUE:
-                hsv_cur.h = angle;
-                break;
-            case LV_CPICKER_COLOR_MODE_SATURATION:
-                hsv_cur.s = (angle * 100) / 360;
-                break;
-            case LV_CPICKER_COLOR_MODE_VALUE:
-                hsv_cur.v = (angle * 100) / 360;
-                break;
-        }
-
-        if(lv_cpicker_set_hsv(cpicker, hsv_cur)) {
-            res = lv_event_send(cpicker, LV_EVENT_VALUE_CHANGED, NULL);
-            if(res != LV_RES_OK) return res;
-        }
-    }
-    else if(sign == LV_SIGNAL_HIT_TEST) {
-        lv_hit_test_info_t * info = param;
-        info->result = lv_cpicker_hit(cpicker, info->point);
-    }
-
-    return res;
-}
-
-
-/**
- * Get the style_list descriptor of a part of the object
- * @param cpicker pointer the object
- * @param part the part of the cpicker. (LV_PAGE_CPICKER_...)
- * @return pointer to the style_list descriptor of the specified part
- */
-static lv_style_list_t * lv_cpicker_get_style(lv_obj_t * cpicker, uint8_t part)
-{
-    LV_ASSERT_OBJ(cpicker, LV_OBJX_NAME);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_CPICKER_PART_MAIN :
-            style_dsc_p = &cpicker->style_list;
-            break;
-        case LV_CPICKER_PART_KNOB:
-            style_dsc_p = &ext->knob.style_list;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-static bool lv_cpicker_hit(lv_obj_t * cpicker, const lv_point_t * p)
-{
-    bool is_point_on_coords = lv_obj_is_point_on_coords(cpicker, p);
-    if(!is_point_on_coords)
-        return false;
-
-    lv_cpicker_ext_t * ext = (lv_cpicker_ext_t *)lv_obj_get_ext_attr(cpicker);
-    if(ext->type == LV_CPICKER_TYPE_RECT)
-        return true;
-
-
-    /*Valid clicks can be only in the circle*/
-    if(_lv_area_is_point_on(&cpicker->coords, p, LV_RADIUS_CIRCLE)) return true;
-    else return false;
-}
-
-static void next_color_mode(lv_obj_t * cpicker)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    ext->color_mode = (ext->color_mode + 1) % 3;
-    refr_knob_pos(cpicker);
-    lv_obj_invalidate(cpicker);
-}
-
-static void refr_knob_pos(lv_obj_t * cpicker)
-{
-    invalidate_knob(cpicker);
-
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    lv_coord_t w = lv_obj_get_width(cpicker);
-    lv_coord_t h = lv_obj_get_height(cpicker);
-
-    if(ext->type == LV_CPICKER_TYPE_RECT) {
-        lv_coord_t ind_pos = 0;
-        switch(ext->color_mode) {
-            case LV_CPICKER_COLOR_MODE_HUE:
-                ind_pos += (ext->hsv.h * w) / 360;
-                break;
-            case LV_CPICKER_COLOR_MODE_SATURATION:
-                ind_pos += (ext->hsv.s * w) / 100;
-                break;
-            case LV_CPICKER_COLOR_MODE_VALUE:
-                ind_pos += (ext->hsv.v * w) / 100;
-                break;
-        }
-
-        ext->knob.pos.x = ind_pos;
-        ext->knob.pos.y = h / 2;
-    }
-    else if(ext->type == LV_CPICKER_TYPE_DISC) {
-        lv_style_int_t scale_w = lv_obj_get_style_scale_width(cpicker, LV_CPICKER_PART_MAIN);
-        lv_coord_t r = (w - scale_w) / 2;
-        uint16_t angle = get_angle(cpicker);
-        ext->knob.pos.x = (((int32_t)r * _lv_trigo_sin(angle)) >> LV_TRIGO_SHIFT);
-        ext->knob.pos.y = (((int32_t)r * _lv_trigo_sin(angle + 90)) >> LV_TRIGO_SHIFT);
-        ext->knob.pos.x = ext->knob.pos.x + w / 2;
-        ext->knob.pos.y = ext->knob.pos.y + h / 2;
-    }
-
-    invalidate_knob(cpicker);
-}
-
-static lv_res_t double_click_reset(lv_obj_t * cpicker)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    lv_indev_t * indev = lv_indev_get_act();
-    /*Double clicked? Use long press time as double click time out*/
-    if(lv_tick_elaps(ext->last_click_time) < indev->driver.long_press_time) {
-        lv_color_hsv_t hsv_cur;
-        hsv_cur = ext->hsv;
-
-        switch(ext->color_mode) {
-            case LV_CPICKER_COLOR_MODE_HUE:
-                hsv_cur.h = LV_CPICKER_DEF_HUE;
-                break;
-            case LV_CPICKER_COLOR_MODE_SATURATION:
-                hsv_cur.s = LV_CPICKER_DEF_SATURATION;
-                break;
-            case LV_CPICKER_COLOR_MODE_VALUE:
-                hsv_cur.v = LV_CPICKER_DEF_VALUE;
-                break;
-        }
-
-        lv_indev_wait_release(indev);
-
-        if(lv_cpicker_set_hsv(cpicker, hsv_cur)) {
-            lv_res_t res = lv_event_send(cpicker, LV_EVENT_VALUE_CHANGED, NULL);
-            if(res != LV_RES_OK) return res;
-        }
-    }
-    ext->last_click_time = lv_tick_get();
-
-    return LV_RES_OK;
-}
-
-static lv_color_t angle_to_mode_color(lv_obj_t * cpicker, uint16_t angle)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    lv_color_t color;
-    switch(ext->color_mode) {
-        default:
-        case LV_CPICKER_COLOR_MODE_HUE:
-            color = lv_color_hsv_to_rgb(angle % 360, ext->hsv.s, ext->hsv.v);
-            break;
-        case LV_CPICKER_COLOR_MODE_SATURATION:
-            color = lv_color_hsv_to_rgb(ext->hsv.h, ((angle % 360) * 100) / 360, ext->hsv.v);
-            break;
-        case LV_CPICKER_COLOR_MODE_VALUE:
-            color = lv_color_hsv_to_rgb(ext->hsv.h, ext->hsv.s, ((angle % 360) * 100) / 360);
-            break;
-    }
-    return color;
-}
-
-static uint16_t get_angle(lv_obj_t * cpicker)
-{
-    lv_cpicker_ext_t * ext = lv_obj_get_ext_attr(cpicker);
-    uint16_t angle;
-    switch(ext->color_mode) {
-        default:
-        case LV_CPICKER_COLOR_MODE_HUE:
-            angle = ext->hsv.h;
-            break;
-        case LV_CPICKER_COLOR_MODE_SATURATION:
-            angle = (ext->hsv.s * 360) / 100;
-            break;
-        case LV_CPICKER_COLOR_MODE_VALUE:
-            angle = (ext->hsv.v * 360) / 100 ;
-            break;
-    }
-    return angle;
-}
-
-#endif /* LV_USE_CPICKER != 0 */
diff --git a/src/lv_widgets/lv_cpicker.h b/src/lv_widgets/lv_cpicker.h
deleted file mode 100644
index 2aef0d732..000000000
--- a/src/lv_widgets/lv_cpicker.h
+++ /dev/null
@@ -1,229 +0,0 @@
-/**
- * @file lv_cpicker.h
- *
- */
-
-#ifndef LV_CPICKER_H
-#define LV_CPICKER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_CPICKER != 0
-
-#include "../lv_core/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-enum {
-    LV_CPICKER_TYPE_RECT,
-    LV_CPICKER_TYPE_DISC,
-};
-typedef uint8_t lv_cpicker_type_t;
-
-enum {
-    LV_CPICKER_COLOR_MODE_HUE,
-    LV_CPICKER_COLOR_MODE_SATURATION,
-    LV_CPICKER_COLOR_MODE_VALUE
-};
-typedef uint8_t lv_cpicker_color_mode_t;
-
-
-
-/*Data of colorpicker*/
-typedef struct {
-    lv_color_hsv_t hsv;
-    struct {
-        lv_style_list_t style_list;
-        lv_point_t pos;
-        uint8_t colored     : 1;
-
-    } knob;
-    uint32_t last_click_time;
-    uint32_t last_change_time;
-    lv_point_t last_press_point;
-    lv_cpicker_color_mode_t color_mode  : 2;
-    uint8_t color_mode_fixed            : 1;
-    lv_cpicker_type_t type              : 1;
-} lv_cpicker_ext_t;
-
-/*Parts*/
-enum {
-    LV_CPICKER_PART_MAIN = LV_OBJ_PART_MAIN,
-    LV_CPICKER_PART_KNOB = _LV_OBJ_PART_VIRTUAL_LAST,
-    _LV_CPICKER_PART_VIRTUAL_LAST,
-    _LV_CPICKER_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
-};
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a colorpicker objects
- * @param par pointer to an object, it will be the parent of the new colorpicker
- * @param copy pointer to a colorpicker object, if not NULL then the new object will be copied from it
- * @return pointer to the created colorpicker
- */
-lv_obj_t * lv_cpicker_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new type for a colorpicker
- * @param cpicker pointer to a colorpicker object
- * @param type new type of the colorpicker (from 'lv_cpicker_type_t' enum)
- */
-void lv_cpicker_set_type(lv_obj_t * cpicker, lv_cpicker_type_t type);
-
-/**
- * Set the current hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param hue current selected hue [0..360]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_hue(lv_obj_t * cpicker, uint16_t hue);
-
-/**
- * Set the current saturation of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param saturation current selected saturation [0..100]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_saturation(lv_obj_t * cpicker, uint8_t saturation);
-
-/**
- * Set the current value of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param val current selected value [0..100]
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_value(lv_obj_t * cpicker, uint8_t val);
-
-/**
- * Set the current hsv of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param hsv current selected hsv
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_hsv(lv_obj_t * cpicker, lv_color_hsv_t hsv);
-
-/**
- * Set the current color of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @param color current selected color
- * @return true if changed, otherwise false
- */
-bool lv_cpicker_set_color(lv_obj_t * cpicker, lv_color_t color);
-
-/**
- * Set the current color mode.
- * @param cpicker pointer to colorpicker object
- * @param mode color mode (hue/sat/val)
- */
-void lv_cpicker_set_color_mode(lv_obj_t * cpicker, lv_cpicker_color_mode_t mode);
-
-/**
- * Set if the color mode is changed on long press on center
- * @param cpicker pointer to colorpicker object
- * @param fixed color mode cannot be changed on long press
- */
-void lv_cpicker_set_color_mode_fixed(lv_obj_t * cpicker, bool fixed);
-
-/**
- * Make the knob to be colored to the current color
- * @param cpicker pointer to colorpicker object
- * @param en true: color the knob; false: not color the knob
- */
-void lv_cpicker_set_knob_colored(lv_obj_t * cpicker, bool en);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the current color mode.
- * @param cpicker pointer to colorpicker object
- * @return color mode (hue/sat/val)
- */
-lv_cpicker_color_mode_t lv_cpicker_get_color_mode(lv_obj_t * cpicker);
-
-/**
- * Get if the color mode is changed on long press on center
- * @param cpicker pointer to colorpicker object
- * @return mode cannot be changed on long press
- */
-bool lv_cpicker_get_color_mode_fixed(lv_obj_t * cpicker);
-
-/**
- * Get the current hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected hue
- */
-uint16_t lv_cpicker_get_hue(lv_obj_t * cpicker);
-
-/**
- * Get the current saturation of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected saturation
- */
-uint8_t lv_cpicker_get_saturation(lv_obj_t * cpicker);
-
-/**
- * Get the current hue of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected value
- */
-uint8_t lv_cpicker_get_value(lv_obj_t * cpicker);
-
-/**
- * Get the current selected hsv of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected hsv
- */
-lv_color_hsv_t lv_cpicker_get_hsv(lv_obj_t * cpicker);
-
-/**
- * Get the current selected color of a colorpicker.
- * @param cpicker pointer to colorpicker object
- * @return current selected color
- */
-lv_color_t lv_cpicker_get_color(lv_obj_t * cpicker);
-
-/**
- * Whether the knob is colored to the current color or not
- * @param cpicker pointer to color picker object
- * @return true: color the knob; false: not color the knob
- */
-bool lv_cpicker_get_knob_colored(lv_obj_t * cpicker);
-
-/*=====================
- * Other functions
- *====================*/
-
-/**********************
- *      MACROS
- **********************/
-
-#endif  /*LV_USE_CPICKER*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif  /*LV_CPICKER_H*/
diff --git a/src/lv_widgets/lv_keyboard.c b/src/lv_widgets/lv_keyboard.c
deleted file mode 100644
index 9138b171e..000000000
--- a/src/lv_widgets/lv_keyboard.c
+++ /dev/null
@@ -1,479 +0,0 @@
-
-/**
- * @file lv_kb.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_keyboard.h"
-#if LV_USE_KEYBOARD != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-#include "lv_textarea.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_keyboard"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_keyboard_signal(lv_obj_t * kb, lv_signal_t sign, void * param);
-static void lv_keyboard_update_map(lv_obj_t * kb);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-/* clang-format off */
-static const char * const default_kb_map_lc[] = {"1#", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p", LV_SYMBOL_BACKSPACE, "\n",
-                                                 "ABC", "a", "s", "d", "f", "g", "h", "j", "k", "l", LV_SYMBOL_NEW_LINE, "\n",
-                                                 "_", "-", "z", "x", "c", "v", "b", "n", "m", ".", ",", ":", "\n",
-                                                 LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
-                                                };
-
-static const lv_btnmatrix_ctrl_t default_kb_ctrl_lc_map[] = {
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, 2, 6, 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
-};
-
-static const char * const default_kb_map_uc[] = {"1#", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", LV_SYMBOL_BACKSPACE, "\n",
-                                                 "abc", "A", "S", "D", "F", "G", "H", "J", "K", "L", LV_SYMBOL_NEW_LINE, "\n",
-                                                 "_", "-", "Z", "X", "C", "V", "B", "N", "M", ".", ",", ":", "\n",
-                                                 LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
-                                                };
-
-static const lv_btnmatrix_ctrl_t default_kb_ctrl_uc_map[] = {
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, 2, 6, 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
-};
-
-static const char * const default_kb_map_spec[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", LV_SYMBOL_BACKSPACE, "\n",
-                                                   "abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
-                                                   "\\",  "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
-                                                   LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
-                                                  };
-
-static const lv_btnmatrix_ctrl_t default_kb_ctrl_spec_map[] = {
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, 2, 6, 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
-};
-
-static const char * const default_kb_map_num[] = {"1", "2", "3", LV_SYMBOL_CLOSE, "\n",
-                                                  "4", "5", "6", LV_SYMBOL_OK, "\n",
-                                                  "7", "8", "9", LV_SYMBOL_BACKSPACE, "\n",
-                                                  "+/-", "0", ".", LV_SYMBOL_LEFT, LV_SYMBOL_RIGHT, ""
-                                                 };
-
-static const lv_btnmatrix_ctrl_t default_kb_ctrl_num_map[] = {
-    1, 1, 1, LV_KEYBOARD_CTRL_BTN_FLAGS | 2,
-    1, 1, 1, LV_KEYBOARD_CTRL_BTN_FLAGS | 2,
-    1, 1, 1, 2,
-    1, 1, 1, 1, 1
-};
-/* clang-format on */
-
-static const char * * kb_map[4] = {
-    (const char * *)default_kb_map_lc,
-    (const char * *)default_kb_map_uc,
-    (const char * *)default_kb_map_spec,
-    (const char * *)default_kb_map_num
-};
-static const lv_btnmatrix_ctrl_t * kb_ctrl[4] = {
-    default_kb_ctrl_lc_map,
-    default_kb_ctrl_uc_map,
-    default_kb_ctrl_spec_map,
-    default_kb_ctrl_num_map
-};
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a keyboard objects
- * @param par pointer to an object, it will be the parent of the new keyboard
- * @param copy pointer to a keyboard object, if not NULL then the new object will be copied from it
- * @return pointer to the created keyboard
- */
-lv_obj_t * lv_keyboard_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("keyboard create started");
-
-    /*Create the ancestor of keyboard*/
-    lv_obj_t * kb = lv_btnmatrix_create(par, copy);
-    LV_ASSERT_MEM(kb);
-    if(kb == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(kb);
-
-    /*Allocate the keyboard type specific extended data*/
-    lv_keyboard_ext_t * ext = lv_obj_allocate_ext_attr(kb, sizeof(lv_keyboard_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(kb);
-        return NULL;
-    }
-
-    /*Initialize the allocated 'ext' */
-    ext->ta         = NULL;
-    ext->mode       = LV_KEYBOARD_MODE_TEXT_LOWER;
-    ext->cursor_mng = 0;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(kb, lv_keyboard_signal);
-
-    /*Init the new keyboard keyboard*/
-    if(copy == NULL) {
-        /* Set a size which fits into the parent.
-         * Don't use `par` directly because if the window is created on a page it is moved to the
-         * scrollable so the parent has changed */
-        lv_obj_set_size(kb, lv_obj_get_width_fit(lv_obj_get_parent(kb)),
-                        lv_obj_get_height_fit(lv_obj_get_parent(kb)) / 2);
-        lv_obj_align(kb, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
-        lv_obj_set_event_cb(kb, lv_keyboard_def_event_cb);
-        lv_obj_set_base_dir(kb, LV_BIDI_DIR_LTR);
-        lv_obj_add_protect(kb, LV_PROTECT_CLICK_FOCUS);
-
-        lv_btnmatrix_set_map(kb, kb_map[ext->mode]);
-        lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[ext->mode]);
-
-        lv_theme_apply(kb, LV_THEME_KEYBOARD);
-    }
-    /*Copy an existing keyboard*/
-    else {
-        lv_keyboard_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->ta                = copy_ext->ta;
-        ext->mode              = copy_ext->mode;
-        ext->cursor_mng        = copy_ext->cursor_mng;
-
-        lv_btnmatrix_set_map(kb, kb_map[ext->mode]);
-        lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[ext->mode]);
-
-        /*Refresh the style with new signal function*/
-        //        lv_obj_refresh_style(new_kb);
-    }
-
-    LV_LOG_INFO("keyboard created");
-
-    return kb;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Assign a Text Area to the Keyboard. The pressed characters will be put there.
- * @param kb pointer to a Keyboard object
- * @param ta pointer to a Text Area object to write there
- */
-void lv_keyboard_set_textarea(lv_obj_t * kb, lv_obj_t * ta)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-    if(ta) LV_ASSERT_OBJ(ta, "lv_textarea");
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-
-    /*Hide the cursor of the old Text area if cursor management is enabled*/
-    if(ext->ta && ext->cursor_mng) {
-        lv_textarea_set_cursor_hidden(ext->ta, true);
-    }
-
-    ext->ta = ta;
-
-    /*Show the cursor of the new Text area if cursor management is enabled*/
-    if(ext->ta && ext->cursor_mng) {
-        lv_textarea_set_cursor_hidden(ext->ta, false);
-    }
-}
-
-/**
- * Set a new a mode (text or number map)
- * @param kb pointer to a Keyboard object
- * @param mode the mode from 'lv_keyboard_mode_t'
- */
-void lv_keyboard_set_mode(lv_obj_t * kb, lv_keyboard_mode_t mode)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    if(ext->mode == mode) return;
-
-    ext->mode = mode;
-    lv_btnmatrix_set_map(kb, kb_map[mode]);
-    lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[mode]);
-}
-
-/**
- * Automatically hide or show the cursor of Text Area
- * @param kb pointer to a Keyboard object
- * @param en true: show cursor on the current text area, false: hide cursor
- */
-void lv_keyboard_set_cursor_manage(lv_obj_t * kb, bool en)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    if(ext->cursor_mng == en) return;
-
-    ext->cursor_mng = en == false ? 0 : 1;
-
-    if(ext->ta) {
-
-        if(ext->cursor_mng) {
-            lv_textarea_set_cursor_hidden(ext->ta, false);
-        }
-        else {
-            lv_textarea_set_cursor_hidden(ext->ta, true);
-        }
-    }
-}
-
-/**
- * Set a new map for the keyboard
- * @param kb pointer to a Keyboard object
- * @param mode keyboard map to alter 'lv_keyboard_mode_t'
- * @param map pointer to a string array to describe the map.
- *            See 'lv_btnmatrix_set_map()' for more info.
- */
-void lv_keyboard_set_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const char * map[])
-{
-    kb_map[mode] = map;
-    lv_keyboard_update_map(kb);
-}
-
-/**
- * Set the button control map (hidden, disabled etc.) for the keyboard. The
- * control map array will be copied and so may be deallocated after this
- * function returns.
- * @param kb pointer to a keyboard object
- * @param mode keyboard ctrl map to alter 'lv_keyboard_mode_t'
- * @param ctrl_map pointer to an array of `lv_btn_ctrl_t` control bytes.
- *                 See: `lv_btnmatrix_set_ctrl_map` for more details.
- */
-void lv_keyboard_set_ctrl_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const lv_btnmatrix_ctrl_t ctrl_map[])
-{
-    kb_ctrl[mode] = ctrl_map;
-    lv_keyboard_update_map(kb);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Assign a Text Area to the Keyboard. The pressed characters will be put there.
- * @param kb pointer to a Keyboard object
- * @return pointer to the assigned Text Area object
- */
-lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * kb)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    return ext->ta;
-}
-
-/**
- * Set a new a mode (text or number map)
- * @param kb pointer to a Keyboard object
- * @return the current mode from 'lv_keyboard_mode_t'
- */
-lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * kb)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    return ext->mode;
-}
-
-/**
- * Get the current cursor manage mode.
- * @param kb pointer to a Keyboard object
- * @return true: show cursor on the current text area, false: hide cursor
- */
-bool lv_keyboard_get_cursor_manage(const lv_obj_t * kb)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    return ext->cursor_mng == 0 ? false : true;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Default keyboard event to add characters to the Text area and change the map.
- * If a custom `event_cb` is added to the keyboard this function be called from it to handle the
- * button clicks
- * @param kb pointer to a  keyboard
- * @param event the triggering event
- */
-void lv_keyboard_def_event_cb(lv_obj_t * kb, lv_event_t event)
-{
-    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
-
-    if(event != LV_EVENT_VALUE_CHANGED) return;
-
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    uint16_t btn_id   = lv_btnmatrix_get_active_btn(kb);
-    if(btn_id == LV_BTNMATRIX_BTN_NONE) return;
-    if(lv_btnmatrix_get_btn_ctrl(kb, btn_id, LV_BTNMATRIX_CTRL_HIDDEN | LV_BTNMATRIX_CTRL_DISABLED)) return;
-    if(lv_btnmatrix_get_btn_ctrl(kb, btn_id, LV_BTNMATRIX_CTRL_NO_REPEAT) && event == LV_EVENT_LONG_PRESSED_REPEAT) return;
-
-    const char * txt = lv_btnmatrix_get_active_btn_text(kb);
-    if(txt == NULL) return;
-
-    /*Do the corresponding action according to the text of the button*/
-    if(strcmp(txt, "abc") == 0) {
-        ext->mode = LV_KEYBOARD_MODE_TEXT_LOWER;
-        lv_btnmatrix_set_map(kb, kb_map[LV_KEYBOARD_MODE_TEXT_LOWER]);
-        lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[LV_KEYBOARD_MODE_TEXT_LOWER]);
-        return;
-    }
-    else if(strcmp(txt, "ABC") == 0) {
-        ext->mode = LV_KEYBOARD_MODE_TEXT_UPPER;
-        lv_btnmatrix_set_map(kb, kb_map[LV_KEYBOARD_MODE_TEXT_UPPER]);
-        lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[LV_KEYBOARD_MODE_TEXT_UPPER]);
-        return;
-    }
-    else if(strcmp(txt, "1#") == 0) {
-        ext->mode = LV_KEYBOARD_MODE_SPECIAL;
-        lv_btnmatrix_set_map(kb, kb_map[LV_KEYBOARD_MODE_SPECIAL]);
-        lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[LV_KEYBOARD_MODE_SPECIAL]);
-        return;
-    }
-    else if(strcmp(txt, LV_SYMBOL_CLOSE) == 0) {
-        if(kb->event_cb != lv_keyboard_def_event_cb) {
-            lv_res_t res = lv_event_send(kb, LV_EVENT_CANCEL, NULL);
-            if(res != LV_RES_OK) return;
-        }
-        else {
-            lv_keyboard_set_textarea(kb, NULL); /*De-assign the text area  to hide it cursor if needed*/
-            lv_obj_del(kb);
-            return;
-        }
-        return;
-    }
-    else if(strcmp(txt, LV_SYMBOL_OK) == 0) {
-        if(kb->event_cb != lv_keyboard_def_event_cb) {
-            lv_res_t res = lv_event_send(kb, LV_EVENT_APPLY, NULL);
-            if(res != LV_RES_OK) return;
-        }
-        else {
-            lv_keyboard_set_textarea(kb, NULL); /*De-assign the text area to hide it cursor if needed*/
-        }
-        return;
-    }
-
-    /*Add the characters to the text area if set*/
-    if(ext->ta == NULL) return;
-
-    if(strcmp(txt, "Enter") == 0 || strcmp(txt, LV_SYMBOL_NEW_LINE) == 0)
-        lv_textarea_add_char(ext->ta, '\n');
-    else if(strcmp(txt, LV_SYMBOL_LEFT) == 0)
-        lv_textarea_cursor_left(ext->ta);
-    else if(strcmp(txt, LV_SYMBOL_RIGHT) == 0)
-        lv_textarea_cursor_right(ext->ta);
-    else if(strcmp(txt, LV_SYMBOL_BACKSPACE) == 0)
-        lv_textarea_del_char(ext->ta);
-    else if(strcmp(txt, "+/-") == 0) {
-        uint16_t cur        = lv_textarea_get_cursor_pos(ext->ta);
-        const char * ta_txt = lv_textarea_get_text(ext->ta);
-        if(ta_txt[0] == '-') {
-            lv_textarea_set_cursor_pos(ext->ta, 1);
-            lv_textarea_del_char(ext->ta);
-            lv_textarea_add_char(ext->ta, '+');
-            lv_textarea_set_cursor_pos(ext->ta, cur);
-        }
-        else if(ta_txt[0] == '+') {
-            lv_textarea_set_cursor_pos(ext->ta, 1);
-            lv_textarea_del_char(ext->ta);
-            lv_textarea_add_char(ext->ta, '-');
-            lv_textarea_set_cursor_pos(ext->ta, cur);
-        }
-        else {
-            lv_textarea_set_cursor_pos(ext->ta, 0);
-            lv_textarea_add_char(ext->ta, '-');
-            lv_textarea_set_cursor_pos(ext->ta, cur + 1);
-        }
-    }
-    else {
-        lv_textarea_add_text(ext->ta, txt);
-    }
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the keyboard
- * @param kb pointer to a keyboard object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_keyboard_signal(lv_obj_t * kb, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(kb, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    }
-    else if(sign == LV_SIGNAL_FOCUS) {
-        lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-        /*Show the cursor of the Text area if cursor management is enabled*/
-        if(ext->ta && ext->cursor_mng) {
-            lv_textarea_set_cursor_hidden(ext->ta, false);
-        }
-    }
-    else if(sign == LV_SIGNAL_DEFOCUS) {
-        lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-        /*Show the cursor of the Text area if cursor management is enabled*/
-        if(ext->ta && ext->cursor_mng) {
-            lv_textarea_set_cursor_hidden(ext->ta, true);
-        }
-    }
-
-    return res;
-}
-
-/**
- * Update the key map for the current mode
- * @param kb pointer to a keyboard object
- */
-static void lv_keyboard_update_map(lv_obj_t * kb)
-{
-    lv_keyboard_ext_t * ext = lv_obj_get_ext_attr(kb);
-    lv_btnmatrix_set_map(kb, kb_map[ext->mode]);
-    lv_btnmatrix_set_ctrl_map(kb, kb_ctrl[ext->mode]);
-}
-
-#endif
diff --git a/src/lv_widgets/lv_keyboard.h b/src/lv_widgets/lv_keyboard.h
deleted file mode 100644
index 3edd344b0..000000000
--- a/src/lv_widgets/lv_keyboard.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * @file lv_keyboard.h
- *
- */
-
-#ifndef LV_KEYBOARD_H
-#define LV_KEYBOARD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_KEYBOARD != 0
-
-/*Testing of dependencies*/
-#if LV_USE_BTNMATRIX == 0
-#error "lv_kb: lv_btnm is required. Enable it in lv_conf.h (LV_USE_BTNMATRIX  1) "
-#endif
-
-#if LV_USE_TEXTAREA == 0
-#error "lv_kb: lv_ta is required. Enable it in lv_conf.h (LV_USE_TEXTAREA  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "lv_btnmatrix.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_KEYBOARD_CTRL_BTN_FLAGS (LV_BTNMATRIX_CTRL_NO_REPEAT | LV_BTNMATRIX_CTRL_CLICK_TRIG)
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/** Current keyboard mode. */
-enum {
-    LV_KEYBOARD_MODE_TEXT_LOWER,
-    LV_KEYBOARD_MODE_TEXT_UPPER,
-    LV_KEYBOARD_MODE_SPECIAL,
-    LV_KEYBOARD_MODE_NUM,
-};
-typedef uint8_t lv_keyboard_mode_t;
-
-/*Data of keyboard*/
-typedef struct {
-    lv_btnmatrix_ext_t btnm; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * ta;          /*Pointer to the assigned text area*/
-    lv_keyboard_mode_t mode;      /*Key map type*/
-    uint8_t cursor_mng : 1; /*1: automatically show/hide cursor when a text area is assigned or left*/
-} lv_keyboard_ext_t;
-
-enum {
-    LV_KEYBOARD_PART_BG,
-    LV_KEYBOARD_PART_BTN,
-};
-typedef uint8_t lv_keyboard_style_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a keyboard objects
- * @param par pointer to an object, it will be the parent of the new keyboard
- * @param copy pointer to a keyboard object, if not NULL then the new object will be copied from it
- * @return pointer to the created keyboard
- */
-lv_obj_t * lv_keyboard_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Assign a Text Area to the Keyboard. The pressed characters will be put there.
- * @param kb pointer to a Keyboard object
- * @param ta pointer to a Text Area object to write there
- */
-void lv_keyboard_set_textarea(lv_obj_t * kb, lv_obj_t * ta);
-
-/**
- * Set a new a mode (text or number map)
- * @param kb pointer to a Keyboard object
- * @param mode the mode from 'lv_keyboard_mode_t'
- */
-void lv_keyboard_set_mode(lv_obj_t * kb, lv_keyboard_mode_t mode);
-
-/**
- * Automatically hide or show the cursor of the current Text Area
- * @param kb pointer to a Keyboard object
- * @param en true: show cursor on the current text area, false: hide cursor
- */
-void lv_keyboard_set_cursor_manage(lv_obj_t * kb, bool en);
-
-/**
- * Set a new map for the keyboard
- * @param kb pointer to a Keyboard object
- * @param mode keyboard map to alter 'lv_keyboard_mode_t'
- * @param map pointer to a string array to describe the map.
- *            See 'lv_btnmatrix_set_map()' for more info.
- */
-void lv_keyboard_set_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const char * map[]);
-
-/**
- * Set the button control map (hidden, disabled etc.) for the keyboard. The
- * control map array will be copied and so may be deallocated after this
- * function returns.
- * @param kb pointer to a keyboard object
- * @param mode keyboard ctrl map to alter 'lv_keyboard_mode_t'
- * @param ctrl_map pointer to an array of `lv_btn_ctrl_t` control bytes.
- *                 See: `lv_btnmatrix_set_ctrl_map` for more details.
- */
-void lv_keyboard_set_ctrl_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const lv_btnmatrix_ctrl_t ctrl_map[]);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Assign a Text Area to the Keyboard. The pressed characters will be put there.
- * @param kb pointer to a Keyboard object
- * @return pointer to the assigned Text Area object
- */
-lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * kb);
-
-/**
- * Set a new a mode (text or number map)
- * @param kb pointer to a Keyboard object
- * @return the current mode from 'lv_keyboard_mode_t'
- */
-lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * kb);
-
-/**
- * Get the current cursor manage mode.
- * @param kb pointer to a Keyboard object
- * @return true: show cursor on the current text area, false: hide cursor
- */
-bool lv_keyboard_get_cursor_manage(const lv_obj_t * kb);
-
-/**
- * Get the current map of a keyboard
- * @param kb pointer to a keyboard object
- * @return the current map
- */
-static inline const char ** lv_keyboard_get_map_array(const lv_obj_t * kb)
-{
-    return lv_btnmatrix_get_map_array(kb);
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Default keyboard event to add characters to the Text area and change the map.
- * If a custom `event_cb` is added to the keyboard this function be called from it to handle the
- * button clicks
- * @param kb pointer to a  keyboard
- * @param event the triggering event
- */
-void lv_keyboard_def_event_cb(lv_obj_t * kb, lv_event_t event);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_KEYBOARD*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_KEYBOARD_H*/
diff --git a/src/lv_widgets/lv_label.c b/src/lv_widgets/lv_label.c
index 8dd5d84e8..bef0ec357 100644
--- a/src/lv_widgets/lv_label.c
+++ b/src/lv_widgets/lv_label.c
@@ -70,16 +70,15 @@ static lv_signal_cb_t ancestor_signal;
 
 /**
  * Create a label objects
- * @param par pointer to an object, it will be the parent of the new label
- * @param copy pointer to a label object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new label
  * @return pointer to the created button
  */
-lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy)
+lv_obj_t * lv_label_create(lv_obj_t * parent)
 {
     LV_LOG_TRACE("label create started");
 
     /*Create a basic object*/
-    lv_obj_t * new_label = lv_obj_create(par, copy);
+    lv_obj_t * new_label = lv_obj_create(parent);
     LV_ASSERT_MEM(new_label);
     if(new_label == NULL) return NULL;
 
@@ -120,49 +119,14 @@ lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->dot.tmp_ptr   = NULL;
     ext->dot_tmp_alloc = 0;
 
-
     lv_obj_set_design_cb(new_label, lv_label_design);
     lv_obj_set_signal_cb(new_label, lv_label_signal);
 
     /*Init the new label*/
-    if(copy == NULL) {
-        lv_theme_apply(new_label, LV_THEME_LABEL);
-        lv_obj_clear_flag(new_label, LV_OBJ_FLAG_CLICKABLE);
-        lv_label_set_long_mode(new_label, LV_LABEL_LONG_EXPAND);
-        lv_label_set_text(new_label, "Text");
-    }
-    /*Copy 'copy' if not NULL*/
-    else {
-        lv_label_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        lv_label_set_long_mode(new_label, lv_label_get_long_mode(copy));
-        lv_label_set_recolor(new_label, lv_label_get_recolor(copy));
-        lv_label_set_align(new_label, lv_label_get_align(copy));
-        if(copy_ext->static_txt == 0)
-            lv_label_set_text(new_label, lv_label_get_text(copy));
-        else
-            lv_label_set_text_static(new_label, lv_label_get_text(copy));
-
-        /*In DOT mode save the text byte-to-byte because a '\0' can be in the middle*/
-        if(copy_ext->long_mode == LV_LABEL_LONG_DOT) {
-            ext->text = lv_mem_realloc(ext->text, _lv_mem_get_size(copy_ext->text));
-            LV_ASSERT_MEM(ext->text);
-            if(ext->text == NULL) return NULL;
-            _lv_memcpy(ext->text, copy_ext->text, _lv_mem_get_size(copy_ext->text));
-        }
-
-        if(copy_ext->dot_tmp_alloc && copy_ext->dot.tmp_ptr) {
-            uint32_t len = (uint32_t)strlen(copy_ext->dot.tmp_ptr);
-            lv_label_set_dot_tmp(new_label, ext->dot.tmp_ptr, len);
-        }
-        else {
-            _lv_memcpy(ext->dot.tmp, copy_ext->dot.tmp, sizeof(ext->dot.tmp));
-        }
-        ext->dot_tmp_alloc = copy_ext->dot_tmp_alloc;
-        ext->dot_end       = copy_ext->dot_end;
-
-        /*Refresh the style with new signal function*/
-        _lv_obj_refresh_style(new_label, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
+    lv_theme_apply(new_label, LV_THEME_LABEL);
+    lv_obj_clear_flag(new_label, LV_OBJ_FLAG_CLICKABLE);
+    lv_label_set_long_mode(new_label, LV_LABEL_LONG_EXPAND);
+    lv_label_set_text(new_label, "Text");
 
     LV_LOG_INFO("label created");
 
diff --git a/src/lv_widgets/lv_label.h b/src/lv_widgets/lv_label.h
index 1a32ef74f..99e517e31 100644
--- a/src/lv_widgets/lv_label.h
+++ b/src/lv_widgets/lv_label.h
@@ -111,11 +111,10 @@ typedef uint8_t lv_label_part_t;
 
 /**
  * Create a label objects
- * @param par pointer to an object, it will be the parent of the new label
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new label
  * @return pointer to the created button
  */
-lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy);
+lv_obj_t * lv_label_create(lv_obj_t * parent);
 
 /*=====================
  * Setter functions
diff --git a/src/lv_widgets/lv_led.c b/src/lv_widgets/lv_led.c
deleted file mode 100644
index dea778d7d..000000000
--- a/src/lv_widgets/lv_led.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/**
- * @file lv_led.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_led.h"
-#if LV_USE_LED != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_draw/lv_draw.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_led"
-
-#define LV_LED_WIDTH_DEF (LV_DPI / 3)
-#define LV_LED_HEIGHT_DEF (LV_DPI / 3)
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_design_res_t lv_led_design(lv_obj_t * led, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_led_signal(lv_obj_t * led, lv_signal_t sign, void * param);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_cb_t ancestor_design;
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a led objects
- * @param par pointer to an object, it will be the parent of the new led
- * @param copy pointer to a led object, if not NULL then the new object will be copied from it
- * @return pointer to the created led
- */
-lv_obj_t * lv_led_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("led create started");
-
-    /*Create the ancestor basic object*/
-    lv_obj_t * led = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(led);
-    if(led == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(led);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(led);
-
-    /*Allocate the object type specific extended data*/
-    lv_led_ext_t * ext = lv_obj_allocate_ext_attr(led, sizeof(lv_led_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(led);
-        return NULL;
-    }
-
-    ext->bright = LV_LED_BRIGHT_MAX;
-
-    lv_obj_set_signal_cb(led, lv_led_signal);
-    lv_obj_set_design_cb(led, lv_led_design);
-
-    /*Init the new led object*/
-    if(copy == NULL) {
-        lv_obj_set_size(led, LV_LED_WIDTH_DEF, LV_LED_HEIGHT_DEF);
-
-        lv_theme_apply(led, LV_THEME_LED);
-    }
-    /*Copy an existing object*/
-    else {
-        lv_led_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->bright             = copy_ext->bright;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(led, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("led created");
-
-    return led;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the brightness of a LED object
- * @param led pointer to a LED object
- * @param bright LV_LED_BRIGHT_MIN (max. dark) ... LV_LED_BRIGHT_MAX (max. light)
- */
-void lv_led_set_bright(lv_obj_t * led, uint8_t bright)
-{
-    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
-
-    /*Set the brightness*/
-    lv_led_ext_t * ext = lv_obj_get_ext_attr(led);
-    if(ext->bright == bright) return;
-
-    if(bright <= LV_LED_BRIGHT_MIN) bright = LV_LED_BRIGHT_MIN;
-    if(bright >= LV_LED_BRIGHT_MAX) bright = LV_LED_BRIGHT_MAX;
-
-    ext->bright = bright;
-
-    /*Invalidate the object there fore it will be redrawn*/
-    lv_obj_invalidate(led);
-}
-
-/**
- * Light on a LED
- * @param led pointer to a LED object
- */
-void lv_led_on(lv_obj_t * led)
-{
-    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
-
-    lv_led_set_bright(led, LV_LED_BRIGHT_MAX);
-}
-
-/**
- * Light off a LED
- * @param led pointer to a LED object
- */
-void lv_led_off(lv_obj_t * led)
-{
-    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
-
-    lv_led_set_bright(led, LV_LED_BRIGHT_MIN);
-}
-
-/**
- * Toggle the state of a LED
- * @param led pointer to a LED object
- */
-void lv_led_toggle(lv_obj_t * led)
-{
-    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
-
-    uint8_t bright = lv_led_get_bright(led);
-    if(bright > (LV_LED_BRIGHT_MIN + LV_LED_BRIGHT_MAX) >> 1)
-        lv_led_off(led);
-    else
-        lv_led_on(led);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the brightness of a LEd object
- * @param led pointer to LED object
- * @return bright 0 (max. dark) ... 255 (max. light)
- */
-uint8_t lv_led_get_bright(const lv_obj_t * led)
-{
-    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
-
-    lv_led_ext_t * ext = lv_obj_get_ext_attr(led);
-    return ext->bright;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the leds
- * @param led pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_led_design(lv_obj_t * led, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-        /*Return false if the object is not covers the clip_area area*/
-        return ancestor_design(led, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        /*Make darker colors in a temporary style according to the brightness*/
-        lv_led_ext_t * ext       = lv_obj_get_ext_attr(led);
-
-        lv_draw_rect_dsc_t rect_dsc;
-        lv_draw_rect_dsc_init(&rect_dsc);
-        lv_obj_init_draw_rect_dsc(led, LV_LED_PART_MAIN, &rect_dsc);
-
-        /*Mix. the color with black proportionally with brightness*/
-        rect_dsc.bg_color   = lv_color_mix(rect_dsc.bg_color, LV_COLOR_BLACK, ext->bright);
-        rect_dsc.bg_grad_color   = lv_color_mix(rect_dsc.bg_grad_color, LV_COLOR_BLACK, ext->bright);
-        rect_dsc.border_color = lv_color_mix(rect_dsc.border_color, LV_COLOR_BLACK, ext->bright);
-        rect_dsc.shadow_color = lv_color_mix(rect_dsc.shadow_color, LV_COLOR_BLACK, ext->bright);
-
-        /*Set the current shadow width according to brightness proportionally between LV_LED_BRIGHT_OFF
-         * and LV_LED_BRIGHT_ON*/
-        rect_dsc.shadow_width = ((ext->bright - LV_LED_BRIGHT_MIN) * rect_dsc.shadow_width) /
-                                (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
-        rect_dsc.shadow_spread = ((ext->bright - LV_LED_BRIGHT_MIN) * rect_dsc.shadow_spread) /
-                                 (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
-
-        lv_draw_rect(&led->coords, clip_area, &rect_dsc);
-    }
-    return LV_DESIGN_RES_OK;
-}
-
-/**
- * Signal function of the led
- * @param led pointer to a led object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_led_signal(lv_obj_t * led, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(led, sign, param);
-    if(res != LV_RES_OK) return res;
-
-    if(sign == LV_SIGNAL_GET_TYPE) {
-        lv_obj_type_t * buf = param;
-        uint8_t i;
-        for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
-            if(buf->type[i] == NULL) break;
-        }
-        buf->type[i] = "lv_led";
-    }
-
-    return res;
-}
-#endif
diff --git a/src/lv_widgets/lv_led.h b/src/lv_widgets/lv_led.h
deleted file mode 100644
index 7ab33cef1..000000000
--- a/src/lv_widgets/lv_led.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * @file lv_led.h
- *
- */
-
-#ifndef LV_LED_H
-#define LV_LED_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_LED != 0
-
-#include "../lv_core/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of led*/
-typedef struct {
-    /*No inherited ext.*/
-    /*New data for this type */
-    uint8_t bright; /*Current brightness of the LED (0..255)*/
-} lv_led_ext_t;
-
-/*Parts of LED*/
-enum {
-    LV_LED_PART_MAIN = LV_OBJ_PART_MAIN,
-};
-typedef uint8_t lv_led_part_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a led objects
- * @param par pointer to an object, it will be the parent of the new led
- * @param copy pointer to a led object, if not NULL then the new object will be copied from it
- * @return pointer to the created led
- */
-lv_obj_t * lv_led_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/**
- * Set the brightness of a LED object
- * @param led pointer to a LED object
- * @param bright LV_LED_BRIGHT_MIN (max. dark) ... LV_LED_BRIGHT_MAX (max. light)
- */
-void lv_led_set_bright(lv_obj_t * led, uint8_t bright);
-
-/**
- * Light on a LED
- * @param led pointer to a LED object
- */
-void lv_led_on(lv_obj_t * led);
-
-/**
- * Light off a LED
- * @param led pointer to a LED object
- */
-void lv_led_off(lv_obj_t * led);
-
-/**
- * Toggle the state of a LED
- * @param led pointer to a LED object
- */
-void lv_led_toggle(lv_obj_t * led);
-
-/**
- * Get the brightness of a LEd object
- * @param led pointer to LED object
- * @return bright 0 (max. dark) ... 255 (max. light)
- */
-uint8_t lv_led_get_bright(const lv_obj_t * led);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_LED*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_LED_H*/
diff --git a/src/lv_widgets/lv_linemeter.c b/src/lv_widgets/lv_linemeter.c
deleted file mode 100644
index eac998bb9..000000000
--- a/src/lv_widgets/lv_linemeter.c
+++ /dev/null
@@ -1,634 +0,0 @@
-/**
- * @file lv_linemeter.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_linemeter.h"
-#if LV_USE_LINEMETER != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_core/lv_group.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_linemeter"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_design_res_t lv_linemeter_design(lv_obj_t * lmeter, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_linemeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a line meter objects
- * @param par pointer to an object, it will be the parent of the new line meter
- * @param copy pointer to a line meter object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created line meter
- */
-lv_obj_t * lv_linemeter_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("line meter create started");
-
-    /*Create the ancestor of line meter*/
-    lv_obj_t * linemeter = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(linemeter);
-    if(linemeter == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(linemeter);
-
-    /*Allocate the line meter type specific extended data*/
-    lv_linemeter_ext_t * ext = lv_obj_allocate_ext_attr(linemeter, sizeof(lv_linemeter_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(linemeter);
-        return NULL;
-    }
-
-    /*Initialize the allocated 'ext' */
-    ext->min_value   = 0;
-    ext->max_value   = 100;
-    ext->cur_value   = 0;
-    ext->line_cnt    = 18;
-    ext->scale_angle = 240;
-    ext->angle_ofs = 0;
-    ext->mirrored = 0;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(linemeter, lv_linemeter_signal);
-    lv_obj_set_design_cb(linemeter, lv_linemeter_design);
-
-    /*Init the new line meter line meter*/
-    if(copy == NULL) {
-        lv_obj_set_size(linemeter, 3 * LV_DPI / 2, 3 * LV_DPI / 2);
-        lv_theme_apply(linemeter, LV_THEME_LINEMETER);
-    }
-    /*Copy an existing line meter*/
-    else {
-        lv_linemeter_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->scale_angle           = copy_ext->scale_angle;
-        ext->line_cnt              = copy_ext->line_cnt;
-        ext->min_value             = copy_ext->min_value;
-        ext->max_value             = copy_ext->max_value;
-        ext->cur_value             = copy_ext->cur_value;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(linemeter, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("line meter created");
-
-    return linemeter;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new value on the line meter
- * @param lmeter pointer to a line meter object
- * @param value new value
- */
-void lv_linemeter_set_value(lv_obj_t * lmeter, int32_t value)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    if(ext->cur_value == value) return;
-
-    int32_t old_value = ext->cur_value;
-
-    ext->cur_value = value > ext->max_value ? ext->max_value : value;
-    ext->cur_value = ext->cur_value < ext->min_value ? ext->min_value : ext->cur_value;
-
-    int16_t level_old =
-        (int32_t)((int32_t)(old_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
-    int16_t level_new =
-        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
-
-    if(level_new == level_old) {
-        return;
-    }
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t right = lv_obj_get_style_pad_right(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t top = lv_obj_get_style_pad_top(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(lmeter, LV_LINEMETER_PART_MAIN);
-
-    lv_coord_t r_out = (lv_obj_get_width(lmeter) - left - right) / 2 ;
-    lv_coord_t r_in  = r_out - lv_obj_get_style_scale_width(lmeter, LV_LINEMETER_PART_MAIN);
-    if(r_in < 1) r_in = 1;
-
-    lv_coord_t x_ofs  = lmeter->coords.x1 + r_out + left;
-    lv_coord_t y_ofs  = lmeter->coords.y1 + r_out + top;
-    int16_t angle_ofs = ext->angle_ofs + 90 + (360 - ext->scale_angle) / 2;
-
-    lv_style_int_t line_width = lv_obj_get_style_scale_end_line_width(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t end_line_width = lv_obj_get_style_scale_end_line_width(lmeter, LV_LINEMETER_PART_MAIN);
-    line_width = LV_MATH_MAX(line_width, end_line_width);
-
-    int32_t angle_old = (level_old * ext->scale_angle) / (ext->line_cnt - 1);
-
-    /*Use smaller clip area only around the visible line*/
-    int32_t y_in_old  = (int32_t)((int32_t)_lv_trigo_sin(angle_old + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-    int32_t x_in_old  = (int32_t)((int32_t)_lv_trigo_sin(angle_old + 90 + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-
-
-    int32_t y_out_old  = (int32_t)((int32_t)_lv_trigo_sin(angle_old + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-    int32_t x_out_old  = (int32_t)((int32_t)_lv_trigo_sin(angle_old + 90 + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-
-
-
-    int32_t angle_new = (level_new * ext->scale_angle) / (ext->line_cnt - 1);
-
-    /*Use smaller clip area only around the visible line*/
-    int32_t y_in_new  = (int32_t)((int32_t)_lv_trigo_sin(angle_new + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-    int32_t x_in_new  = (int32_t)((int32_t)_lv_trigo_sin(angle_new + 90 + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-
-
-    int32_t y_out_new  = (int32_t)((int32_t)_lv_trigo_sin(angle_new + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-    int32_t x_out_new  = (int32_t)((int32_t)_lv_trigo_sin(angle_new + 90 + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-
-    lv_area_t a;
-    if(x_out_old < 0 && x_out_new < 0) {
-        a.x1 = lmeter->coords.x1 + left - line_width;
-        a.y1 = LV_MATH_MIN4(y_out_old, y_out_new, y_in_old, y_in_new) + y_ofs - line_width;
-        a.x2 = LV_MATH_MAX(x_in_old, x_in_new) + x_ofs + line_width;
-        a.y2 = LV_MATH_MAX4(y_out_old, y_out_new, y_in_old, y_in_new) + y_ofs + line_width;
-    }
-    else if(x_out_old > 0 && x_out_new > 0) {
-        a.x1 = LV_MATH_MIN(x_in_old, x_in_new) + x_ofs - line_width;
-        a.y1 = LV_MATH_MIN4(y_out_old, y_out_new, y_in_old, y_in_new) + y_ofs - line_width;
-        a.x2 = lmeter->coords.x2 - right + line_width;
-        a.y2 = LV_MATH_MAX4(y_out_old, y_out_new, y_in_old, y_in_new) + y_ofs + line_width;
-    }
-    else if(y_out_old < 0 && y_out_new < 0) {
-        a.x1 = LV_MATH_MIN4(x_out_old, x_out_new, x_in_old, x_in_new) + x_ofs - line_width;
-        a.y1 = lmeter->coords.y1 + top - line_width;
-        a.x2 = LV_MATH_MAX4(x_out_old, x_out_new, x_in_old, x_in_new) + x_ofs + line_width;
-        a.y2 = LV_MATH_MAX(y_in_old, y_in_new) + y_ofs + line_width;
-    }
-    else if(y_out_old > 0 && y_out_new > 0) {
-        a.x1 = LV_MATH_MIN4(x_out_old, x_out_new, x_in_old, x_in_new) + x_ofs - line_width;
-        a.y1 = LV_MATH_MIN(y_in_old, y_in_new) + y_ofs - line_width;
-        a.x2 = LV_MATH_MAX4(x_out_old, x_out_new, x_in_old, x_in_new) + x_ofs + line_width;
-        a.y2 = lmeter->coords.y2 - bottom + line_width;
-    }
-    else {
-        a.x1 = lmeter->coords.x1 + left - line_width;
-        a.y1 = lmeter->coords.y1 + top - line_width;
-        a.x2 = lmeter->coords.x2 - right + line_width;
-        a.y2 = lmeter->coords.y2 - bottom + line_width;
-    }
-
-    lv_obj_invalidate_area(lmeter, &a);
-
-}
-
-/**
- * Set minimum and the maximum values of a line meter
- * @param lmeter pointer to he line meter object
- * @param min minimum value
- * @param max maximum value
- */
-void lv_linemeter_set_range(lv_obj_t * lmeter, int32_t min, int32_t max)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    if(ext->min_value == min && ext->max_value == max) return;
-
-    ext->max_value = max;
-    ext->min_value = min;
-    if(ext->cur_value > max) {
-        ext->cur_value = max;
-        lv_linemeter_set_value(lmeter, ext->cur_value);
-    }
-    if(ext->cur_value < min) {
-        ext->cur_value = min;
-        lv_linemeter_set_value(lmeter, ext->cur_value);
-    }
-    lv_obj_invalidate(lmeter);
-}
-
-/**
- * Set the scale settings of a line meter
- * @param lmeter pointer to a line meter object
- * @param angle angle of the scale (0..360)
- * @param line_cnt number of lines
- */
-void lv_linemeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint16_t line_cnt)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    if(ext->scale_angle == angle && ext->line_cnt == line_cnt) return;
-
-    ext->scale_angle = angle;
-    ext->line_cnt    = line_cnt;
-
-    lv_obj_invalidate(lmeter);
-}
-
-/**
- * Set the set an offset for the line meter's angles to rotate it.
- * @param lmeter pointer to a line meter object
- * @param angle angle where the meter will be facing (with its center)
- */
-void lv_linemeter_set_angle_offset(lv_obj_t * lmeter, uint16_t angle)
-{
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    if(ext->angle_ofs == angle) return;
-
-    ext->angle_ofs = angle;
-
-    lv_obj_invalidate(lmeter);
-}
-
-/**
- * Set the orientation of the meter growth, clockwise or counterclockwise (mirrored)
- * @param lmeter pointer to a line meter object
- * @param mirror mirror setting
- */
-void lv_linemeter_set_mirror(lv_obj_t * lmeter, bool mirror)
-{
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    if(ext->mirrored == mirror) return;
-
-    ext->mirrored = mirror;
-
-    lv_obj_invalidate(lmeter);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the value of the line meter
- */
-int32_t lv_linemeter_get_value(const lv_obj_t * lmeter)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    return ext->cur_value;
-}
-
-/**
- * Get the minimum value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the minimum value of the line meter
- */
-int32_t lv_linemeter_get_min_value(const lv_obj_t * lmeter)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    return ext->min_value;
-}
-
-/**
- * Get the maximum value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the maximum value of the line meter
- */
-int32_t lv_linemeter_get_max_value(const lv_obj_t * lmeter)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    return ext->max_value;
-}
-
-/**
- * Get the scale number of a line meter
- * @param lmeter pointer to a line meter object
- * @return number of the scale units
- */
-uint16_t lv_linemeter_get_line_count(const lv_obj_t * lmeter)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    return ext->line_cnt;
-}
-
-/**
- * Get the scale angle of a line meter
- * @param lmeter pointer to a line meter object
- * @return angle_ofs of the scale
- */
-uint16_t lv_linemeter_get_scale_angle(const lv_obj_t * lmeter)
-{
-    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
-
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-    return ext->scale_angle;
-}
-
-/**
- * Get the offset for the line meter.
- * @param lmeter pointer to a line meter object
- * @return angle offset (0..360)
- */
-uint16_t lv_linemeter_get_angle_offset(lv_obj_t * lmeter)
-{
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-
-    return ext->angle_ofs;
-}
-
-/**
- * get the mirror setting for the line meter
- * @param lmeter pointer to a line meter object
- * @return mirror (true or false)
- */
-bool lv_linemeter_get_mirror(lv_obj_t * lmeter)
-{
-    lv_linemeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
-
-    return ext->mirrored;
-}
-
-void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uint8_t part)
-{
-    lv_linemeter_ext_t * ext    = lv_obj_get_ext_attr(lmeter);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t right = lv_obj_get_style_pad_right(lmeter, LV_LINEMETER_PART_MAIN);
-    lv_style_int_t top = lv_obj_get_style_pad_top(lmeter, LV_LINEMETER_PART_MAIN);
-
-    lv_coord_t r_out = (lv_obj_get_width(lmeter) - left - right) / 2 ;
-    lv_coord_t r_in  = r_out - lv_obj_get_style_scale_width(lmeter, part);
-    if(r_in < 1) r_in = 1;
-
-    lv_coord_t x_ofs  = lmeter->coords.x1 + r_out + left;
-    lv_coord_t y_ofs  = lmeter->coords.y1 + r_out + top;
-    int16_t angle_ofs = ext->angle_ofs + 90 + (360 - ext->scale_angle) / 2;
-    int16_t level = ext->mirrored ?
-                    (int32_t)((int32_t)(ext->max_value - ext->cur_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value) :
-                    (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
-    uint8_t i;
-
-    lv_color_t main_color = lv_obj_get_style_line_color(lmeter, part);
-    lv_color_t grad_color = lv_obj_get_style_scale_grad_color(lmeter, part);
-    lv_color_t end_color = lv_obj_get_style_scale_end_color(lmeter, part);
-
-    lv_draw_line_dsc_t line_dsc;
-    lv_draw_line_dsc_init(&line_dsc);
-    lv_obj_init_draw_line_dsc(lmeter, part, &line_dsc);
-#if LV_LINEMETER_PRECISE == 2
-    line_dsc.raw_end = 1;
-#endif
-
-    lv_style_int_t end_line_width = lv_obj_get_style_scale_end_line_width(lmeter, part);
-
-#if LV_LINEMETER_PRECISE > 0
-    lv_area_t mask_area;
-    mask_area.x1 = x_ofs - r_in;
-    mask_area.x2 = x_ofs + r_in - 1;
-    mask_area.y1 = y_ofs - r_in;
-    mask_area.y2 = y_ofs + r_in - 1;
-
-    lv_draw_mask_radius_param_t mask_in_param;
-    lv_draw_mask_radius_init(&mask_in_param, &mask_area, LV_RADIUS_CIRCLE, true);
-    int16_t mask_in_id = lv_draw_mask_add(&mask_in_param, 0);
-#endif
-
-
-#if LV_LINEMETER_PRECISE > 1
-    mask_area.x1 = x_ofs - r_out;
-    mask_area.x2 = x_ofs + r_out - 1;
-    mask_area.y1 = y_ofs - r_out;
-    mask_area.y2 = y_ofs + r_out - 1;
-    lv_draw_mask_radius_param_t mask_out_param;
-    lv_draw_mask_radius_init(&mask_out_param, &mask_area, LV_RADIUS_CIRCLE, false);
-    int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, 0);
-    /*In calculation use a larger radius to avoid rounding errors */
-    lv_coord_t r_out_extra = r_out + LV_DPI;
-#else
-    lv_coord_t r_out_extra = r_out;
-#endif
-
-    for(i = 0; i < ext->line_cnt; i++) {
-        /* `* 256` for extra precision*/
-        int32_t angle_upscale = (i * ext->scale_angle * 256) / (ext->line_cnt - 1);
-        int32_t angle_normal = angle_upscale >> 8;
-
-        int32_t angle_low = (angle_upscale >> 8);
-        int32_t angle_high = angle_low + 1;
-        int32_t angle_rem = angle_upscale & 0xFF;
-
-        /*Interpolate sine and cos*/
-        int32_t sin_low = _lv_trigo_sin(angle_low + angle_ofs);
-        int32_t sin_high = _lv_trigo_sin(angle_high + angle_ofs);
-        int32_t sin_mid = (sin_low * (256 - angle_rem) + sin_high * angle_rem) >> 8;
-
-        int32_t cos_low = _lv_trigo_sin(angle_low + 90 + angle_ofs);
-        int32_t cos_high = _lv_trigo_sin(angle_high + 90 + angle_ofs);
-        int32_t cos_mid = (cos_low * (256 - angle_rem) + cos_high * angle_rem) >> 8;
-
-        /*Use the interpolated values to get x and y coordinates*/
-        int32_t y_out_extra = (int32_t)((int32_t)sin_mid * r_out_extra) >> (LV_TRIGO_SHIFT - 8);
-        int32_t x_out_extra = (int32_t)((int32_t)cos_mid * r_out_extra) >> (LV_TRIGO_SHIFT - 8);
-
-        /*Rounding*/
-        if(x_out_extra > 0) x_out_extra = (x_out_extra + 127) >> 8;
-        else x_out_extra = (x_out_extra - 127) >> 8;
-
-        if(y_out_extra > 0) y_out_extra = (y_out_extra + 127) >> 8;
-        else y_out_extra = (y_out_extra - 127) >> 8;
-
-        x_out_extra += x_ofs;
-        y_out_extra += y_ofs;
-
-        /*With no extra precision use the coordinates on the inner radius*/
-#if LV_LINEMETER_PRECISE == 0
-        /*Use the interpolated values to get x and y coordinates*/
-        int32_t y_in_extra = (int32_t)((int32_t)sin_mid * r_in) >> (LV_TRIGO_SHIFT - 8);
-        int32_t x_in_extra = (int32_t)((int32_t)cos_mid * r_in) >> (LV_TRIGO_SHIFT - 8);
-
-        /*Rounding*/
-        if(x_in_extra > 0) x_in_extra = (x_in_extra + 127) >> 8;
-        else x_in_extra = (x_in_extra - 127) >> 8;
-
-        if(y_in_extra > 0) y_in_extra = (y_in_extra + 127) >> 8;
-        else y_in_extra = (y_in_extra - 127) >> 8;
-
-        x_in_extra += x_ofs;
-        y_in_extra += y_ofs;
-#else
-        int32_t x_in_extra = x_ofs;
-        int32_t y_in_extra = y_ofs;
-#endif
-
-        /*Use smaller clip area only around the visible line*/
-        int32_t y_in  = (int32_t)((int32_t)_lv_trigo_sin(angle_normal + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-        int32_t x_in  = (int32_t)((int32_t)_lv_trigo_sin(angle_normal + 90 + angle_ofs) * r_in) >> LV_TRIGO_SHIFT;
-
-        x_in += x_ofs;
-        y_in += y_ofs;
-
-        int32_t y_out  = (int32_t)((int32_t)_lv_trigo_sin(angle_normal + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-        int32_t x_out  = (int32_t)((int32_t)_lv_trigo_sin(angle_normal + 90 + angle_ofs) * r_out) >> LV_TRIGO_SHIFT;
-
-        x_out += x_ofs;
-        y_out += y_ofs;
-
-        lv_area_t clip_sub;
-        clip_sub.x1 = LV_MATH_MIN(x_in, x_out) - line_dsc.width;
-        clip_sub.x2 = LV_MATH_MAX(x_in, x_out) + line_dsc.width;
-        clip_sub.y1 = LV_MATH_MIN(y_in, y_out) - line_dsc.width;
-        clip_sub.y2 = LV_MATH_MAX(y_in, y_out) + line_dsc.width;
-
-        if(_lv_area_intersect(&clip_sub, &clip_sub, clip_area) == false) continue;
-
-        lv_point_t p1;
-        lv_point_t p2;
-
-        p2.x = x_in_extra;
-        p2.y = y_in_extra;
-
-        p1.x = x_out_extra;
-        p1.y = y_out_extra;
-
-        /* Set the color of the lines */
-<<<<<<< HEAD
-        uint16_t index = ext->mirrored ? ext->line_cnt - i : i;
-=======
->>>>>>> master
-        if((!ext->mirrored && i >= level) || (ext->mirrored && i <= level)) {
-            line_dsc.color = end_color;
-            line_dsc.width = end_line_width;
-        } else {
-            line_dsc.color = lv_color_mix(grad_color, main_color, (255 * i) / ext->line_cnt);
-        }
-
-        lv_draw_line(&p1, &p2, &clip_sub, &line_dsc);
-    }
-
-#if LV_LINEMETER_PRECISE > 0
-    lv_draw_mask_remove_id(mask_in_id);
-#endif
-
-#if LV_LINEMETER_PRECISE > 1
-    lv_draw_mask_remove_id(mask_out_id);
-#endif
-
-    if(part == LV_LINEMETER_PART_MAIN && level + 1 < ext->line_cnt - 1) {
-        lv_style_int_t border_width = lv_obj_get_style_scale_border_width(lmeter, part);
-        lv_style_int_t end_border_width = lv_obj_get_style_scale_end_border_width(lmeter, part);
-
-        if(border_width || end_border_width) {
-            int16_t end_angle = ((level + 1) * ext->scale_angle) / (ext->line_cnt - 1) + angle_ofs;
-            lv_draw_line_dsc_t arc_dsc;
-            lv_draw_line_dsc_init(&arc_dsc);
-            lv_obj_init_draw_line_dsc(lmeter, part, &arc_dsc);
-
-            if(border_width) {
-                arc_dsc.width = border_width;
-                arc_dsc.color = main_color;
-                lv_draw_arc(x_ofs, y_ofs, r_out, angle_ofs, end_angle, clip_area, &arc_dsc);
-            }
-
-            if(end_border_width) {
-                arc_dsc.width = end_border_width;
-                arc_dsc.color = end_color;
-                lv_draw_arc(x_ofs, y_ofs, r_out, end_angle, (angle_ofs + ext->scale_angle) % 360, clip_area, &arc_dsc);
-            }
-        }
-    }
-
-
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the line meters
- * @param lmeter pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_linemeter_design(lv_obj_t * lmeter, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return LV_DESIGN_RES_NOT_COVER;
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        lv_draw_rect_dsc_t bg_dsc;
-        lv_draw_rect_dsc_init(&bg_dsc);
-        lv_obj_init_draw_rect_dsc(lmeter, LV_LINEMETER_PART_MAIN, &bg_dsc);
-        lv_draw_rect(&lmeter->coords, clip_area, &bg_dsc);
-        lv_linemeter_draw_scale(lmeter, clip_area, LV_LINEMETER_PART_MAIN);
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
-/**
- * Signal function of the line meter
- * @param lmeter pointer to a line meter object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_linemeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(lmeter, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        lv_obj_refresh_ext_draw_pad(lmeter);
-        lv_obj_invalidate(lmeter);
-    }
-
-    return res;
-}
-#endif
diff --git a/src/lv_widgets/lv_linemeter.h b/src/lv_widgets/lv_linemeter.h
deleted file mode 100644
index c33bffb27..000000000
--- a/src/lv_widgets/lv_linemeter.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * @file lv_linemeter.h
- *
- */
-
-#ifndef LV_LINEMETER_H
-#define LV_LINEMETER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_LINEMETER != 0
-
-#include "../lv_core/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of line meter*/
-typedef struct {
-    /*No inherited ext.*/ /*Ext. of ancestor*/
-    /*New data for this type */
-    uint16_t scale_angle; /*Angle of the scale in deg. (0..360)*/
-    uint16_t angle_ofs;
-    uint16_t line_cnt;     /*Count of lines */
-    int32_t cur_value;
-    int32_t min_value;
-    int32_t max_value;
-    uint8_t mirrored : 1;
-} lv_linemeter_ext_t;
-
-/*Styles*/
-enum {
-    LV_LINEMETER_PART_MAIN,
-    _LV_LINEMETER_PART_VIRTUAL_LAST,
-    _LV_LINEMETER_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
-};
-typedef uint8_t lv_linemeter_part_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a line meter objects
- * @param par pointer to an object, it will be the parent of the new line meter
- * @param copy pointer to a line meter object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created line meter
- */
-lv_obj_t * lv_linemeter_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new value on the line meter
- * @param lmeter pointer to a line meter object
- * @param value new value
- */
-void lv_linemeter_set_value(lv_obj_t * lmeter, int32_t value);
-
-/**
- * Set minimum and the maximum values of a line meter
- * @param lmeter pointer to he line meter object
- * @param min minimum value
- * @param max maximum value
- */
-void lv_linemeter_set_range(lv_obj_t * lmeter, int32_t min, int32_t max);
-
-/**
- * Set the scale settings of a line meter
- * @param lmeter pointer to a line meter object
- * @param angle angle of the scale (0..360)
- * @param line_cnt number of lines
- */
-void lv_linemeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint16_t line_cnt);
-
-/**
- * Set the set an offset for the line meter's angles to rotate it.
- * @param lmeter pointer to a line meter object
- * @param angle angle offset (0..360), rotates clockwise
- */
-void lv_linemeter_set_angle_offset(lv_obj_t * lmeter, uint16_t angle);
-
-/**
- * Set the orientation of the meter growth, clockwise or counterclockwise (mirrored)
- * @param lmeter pointer to a line meter object
- * @param mirror mirror setting
- */
-void lv_linemeter_set_mirror(lv_obj_t * lmeter, bool mirror);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the value of the line meter
- */
-int32_t lv_linemeter_get_value(const lv_obj_t * lmeter);
-
-/**
- * Get the minimum value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the minimum value of the line meter
- */
-int32_t lv_linemeter_get_min_value(const lv_obj_t * lmeter);
-
-/**
- * Get the maximum value of a line meter
- * @param lmeter pointer to a line meter object
- * @return the maximum value of the line meter
- */
-int32_t lv_linemeter_get_max_value(const lv_obj_t * lmeter);
-
-/**
- * Get the scale number of a line meter
- * @param lmeter pointer to a line meter object
- * @return number of the scale units
- */
-uint16_t lv_linemeter_get_line_count(const lv_obj_t * lmeter);
-
-/**
- * Get the scale angle of a line meter
- * @param lmeter pointer to a line meter object
- * @return angle of the scale
- */
-uint16_t lv_linemeter_get_scale_angle(const lv_obj_t * lmeter);
-
-/**
- * Get the offset for the line meter.
- * @param lmeter pointer to a line meter object
- * @return angle offset (0..360)
- */
-uint16_t lv_linemeter_get_angle_offset(lv_obj_t * lmeter);
-
-
-void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uint8_t part);
-
-/**
- * get the mirror setting for the line meter
- * @param lmeter pointer to a line meter object
- * @return mirror (true or false)
- */
-bool lv_linemeter_get_mirror(lv_obj_t * lmeter);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_LINEMETER*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_LINEMETER_H*/
diff --git a/src/lv_widgets/lv_list.c b/src/lv_widgets/lv_list.c
deleted file mode 100644
index fd8d5a41a..000000000
--- a/src/lv_widgets/lv_list.c
+++ /dev/null
@@ -1,923 +0,0 @@
-/**
- * @file lv_list.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_list.h"
-#if LV_USE_LIST != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_core/lv_group.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_anim.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_list"
-
-#define LV_LIST_LAYOUT_DEF LV_LAYOUT_COLUMN_MID
-
-#if LV_USE_ANIMATION == 0
-    #undef LV_LIST_DEF_ANIM_TIME
-    #define LV_LIST_DEF_ANIM_TIME 0
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param);
-static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_list_get_style(lv_obj_t * list, uint8_t part);
-static bool lv_list_is_list_btn(lv_obj_t * list_btn);
-static bool lv_list_is_list_img(lv_obj_t * list_btn);
-static bool lv_list_is_list_label(lv_obj_t * list_btn);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-#if LV_USE_IMG
-    static lv_signal_cb_t img_signal;
-#endif
-static lv_signal_cb_t label_signal;
-static lv_signal_cb_t ancestor_page_signal;
-static lv_signal_cb_t ancestor_btn_signal;
-
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a list objects
- * @param par pointer to an object, it will be the parent of the new list
- * @param copy pointer to a list object, if not NULL then the new object will be copied from it
- * @return pointer to the created list
- */
-lv_obj_t * lv_list_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("list create started");
-
-    /*Create the ancestor basic object*/
-    lv_obj_t * list = lv_page_create(par, copy);
-    LV_ASSERT_MEM(list);
-    if(list == NULL) return NULL;
-
-    if(ancestor_page_signal == NULL) ancestor_page_signal = lv_obj_get_signal_cb(list);
-
-    lv_list_ext_t * ext = lv_obj_allocate_ext_attr(list, sizeof(lv_list_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(list);
-        return NULL;
-    }
-
-#if LV_USE_GROUP
-    ext->last_sel_btn = NULL;
-#endif
-    ext->act_sel_btn = NULL;
-
-    lv_obj_set_signal_cb(list, lv_list_signal);
-
-    /*Init the new list object*/
-    if(copy == NULL) {
-        lv_page_set_anim_time(list, LV_LIST_DEF_ANIM_TIME);
-        lv_page_set_scrollable_fit2(list, LV_FIT_PARENT, LV_FIT_TIGHT);
-        lv_obj_set_size(list, 2 * LV_DPI, 3 * LV_DPI);
-        lv_page_set_scrl_layout(list, LV_LIST_LAYOUT_DEF);
-        lv_list_set_scrollbar_mode(list, LV_SCROLLBAR_MODE_DRAG);
-
-        lv_theme_apply(list, LV_THEME_LIST);
-
-    }
-    else {
-        lv_obj_t * copy_btn = lv_list_get_next_btn(copy, NULL);
-        while(copy_btn) {
-            const void * img_src = NULL;
-#if LV_USE_IMG
-            lv_obj_t * copy_img = lv_list_get_btn_img(copy_btn);
-            if(copy_img) img_src = lv_img_get_src(copy_img);
-#endif
-            lv_list_add_btn(list, img_src, lv_list_get_btn_text(copy_btn));
-            copy_btn = lv_list_get_next_btn(copy, copy_btn);
-        }
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(list, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("list created");
-
-    return list;
-}
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param list pointer to an object
- */
-void lv_list_clean(lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    lv_obj_t * scrl = lv_page_get_scrollable(list);
-    lv_obj_clean(scrl);
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-/**
- * Add a list element to the list
- * @param list pointer to list object
- * @param img_fn file name of an image before the text (NULL if unused)
- * @param txt text of the list element (NULL if unused)
- * @return pointer to the new list element which can be customized (a button)
- */
-lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * txt)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    lv_obj_t * last_btn = lv_list_get_prev_btn(list, NULL);
-
-    /*The coordinates may changed due to autofit so revert them at the end*/
-    lv_coord_t pos_x_ori = lv_obj_get_x(list);
-    lv_coord_t pos_y_ori = lv_obj_get_y(list);
-
-    lv_obj_t * scrl =  lv_page_get_scrollable(list);
-    lv_obj_add_protect(scrl, LV_PROTECT_CHILD_CHG);
-
-    /*Create a list element with the image an the text*/
-    lv_obj_t * btn;
-    btn = lv_btn_create(list, NULL);
-
-    lv_obj_add_protect(btn, LV_PROTECT_CHILD_CHG);
-
-    /*Save the original signal function because it will be required in `lv_list_btn_signal`*/
-    if(ancestor_btn_signal == NULL) ancestor_btn_signal = lv_obj_get_signal_cb(btn);
-
-    /*Set the default styles*/
-    lv_theme_apply(btn, LV_THEME_LIST_BTN);
-
-    lv_page_glue_obj(list, btn, true);
-    lv_btn_set_layout(btn, LV_LAYOUT_ROW_MID);
-
-    lv_layout_t list_layout = lv_list_get_layout(list);
-    bool layout_ver = false;
-    if(list_layout == LV_LAYOUT_COLUMN_MID || list_layout == LV_LAYOUT_COLUMN_LEFT ||
-       list_layout == LV_LAYOUT_COLUMN_RIGHT) {
-        layout_ver = true;
-    }
-
-    if(layout_ver) {
-        lv_btn_set_fit2(btn, LV_FIT_PARENT, LV_FIT_TIGHT);
-    }
-    else {
-        lv_coord_t w = last_btn ? lv_obj_get_width(last_btn) : (LV_DPI * 3) / 2;
-        lv_btn_set_fit2(btn, LV_FIT_NONE, LV_FIT_TIGHT);
-        lv_obj_set_width(btn, w);
-    }
-
-
-    lv_obj_add_protect(btn, LV_PROTECT_PRESS_LOST);
-    lv_obj_set_signal_cb(btn, lv_list_btn_signal);
-
-
-#if LV_USE_IMG != 0
-    lv_obj_t * img = NULL;
-    if(img_src) {
-        img = lv_img_create(btn, NULL);
-        lv_img_set_src(img, img_src);
-        lv_obj_set_click(img, false);
-        if(img_signal == NULL) img_signal = lv_obj_get_signal_cb(img);
-    }
-#endif
-    if(txt != NULL) {
-        lv_obj_t * label = lv_label_create(btn, NULL);
-        lv_label_set_text(label, txt);
-        lv_obj_set_click(label, false);
-        lv_label_set_long_mode(label, LV_LABEL_LONG_SROLL_CIRC);
-        if(lv_obj_get_base_dir(btn) == LV_BIDI_DIR_RTL) {
-            lv_coord_t pad = lv_obj_get_style_pad_left(btn, LV_BTN_PART_MAIN);
-            lv_obj_set_width(label, label->coords.x2 - btn->coords.x1 - pad);
-        }
-        else {
-            lv_coord_t pad = lv_obj_get_style_pad_right(btn, LV_BTN_PART_MAIN);
-            lv_obj_set_width(label, btn->coords.x2 - label->coords.x1 - pad);
-        }
-        if(label_signal == NULL) label_signal = lv_obj_get_signal_cb(label);
-    }
-
-#if LV_USE_GROUP
-    /* If this is the first item to be added to the list and the list is
-     * focused, select it */
-    {
-        lv_group_t * g = lv_obj_get_group(list);
-        if(lv_list_get_next_btn(list, NULL) == btn && lv_group_get_focused(g) == list) {
-            lv_list_focus_btn(list, btn);
-        }
-    }
-#endif
-
-    lv_obj_clear_protect(scrl, LV_PROTECT_CHILD_CHG);
-    lv_obj_clear_protect(btn, LV_PROTECT_CHILD_CHG);
-    btn->signal_cb(btn, LV_SIGNAL_CHILD_CHG, NULL);
-
-    lv_obj_set_pos(list, pos_x_ori, pos_y_ori);
-
-    return btn;
-}
-
-/**
- * Remove the index of the button in the list
- * @param list pointer to a list object
- * @param index pointer to a the button's index in the list, index must be 0 <= index <
- * lv_list_ext_t.size
- * @return true: successfully deleted
- */
-bool lv_list_remove(const lv_obj_t * list, uint16_t index)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    uint16_t count = 0;
-    lv_obj_t * e   = lv_list_get_next_btn(list, NULL);
-    while(e != NULL) {
-        if(count == index) {
-            lv_obj_del(e);
-            return true;
-        }
-        e = lv_list_get_next_btn(list, e);
-        count++;
-    }
-    return false;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Make a button selected
- * @param list pointer to a list object
- * @param btn pointer to a button to select
- *            NULL to not select any buttons
- */
-void lv_list_focus_btn(lv_obj_t * list, lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-    if(btn) LV_ASSERT_OBJ(btn, "lv_btn");
-
-    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-
-    /*Defocus the current button*/
-    if(ext->act_sel_btn) lv_obj_clear_state(ext->act_sel_btn, LV_STATE_FOCUSED);
-
-#if LV_USE_GROUP
-    /*Don't forget which button was selected.
-     * It will be restored when the list is focused again.*/
-    if(btn) ext->last_sel_btn = btn;
-#endif
-
-    /*Focus the new button*/
-    ext->act_sel_btn = btn;
-
-    if(ext->act_sel_btn) {
-        lv_obj_add_state(ext->act_sel_btn, LV_STATE_FOCUSED);
-        lv_page_focus(list, ext->act_sel_btn, LV_ANIM_ON);
-    }
-}
-
-/**
- * Set layout of a list
- * @param list pointer to a list object
- * @param layout which layout should be used
- */
-void lv_list_set_layout(lv_obj_t * list, lv_layout_t layout)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    /* Update list layout if necessary */
-    if(layout == lv_list_get_layout(list)) return;
-
-    /* Get the first button on the list */
-    lv_obj_t * btn = lv_list_get_prev_btn(list, NULL);
-
-    /* Visit all buttons on the list and update their layout  */
-    while(btn != NULL) {
-        /*If a column layout set the buttons' width to list width*/
-        if(layout == LV_LAYOUT_COLUMN_MID || layout == LV_LAYOUT_COLUMN_LEFT || layout == LV_LAYOUT_COLUMN_RIGHT) {
-            lv_btn_set_fit2(btn, LV_FIT_PARENT, LV_FIT_TIGHT);
-        }
-        /*If a row layout set the buttons' width according to the content*/
-        else if(layout == LV_LAYOUT_ROW_MID || layout == LV_LAYOUT_ROW_TOP || layout == LV_LAYOUT_ROW_BOTTOM) {
-            lv_btn_set_fit(btn, LV_FIT_TIGHT);
-        }
-
-        btn = lv_list_get_prev_btn(list, btn);
-    }
-
-    if(layout == LV_LAYOUT_COLUMN_MID || layout == LV_LAYOUT_COLUMN_LEFT || layout == LV_LAYOUT_COLUMN_RIGHT) {
-        lv_page_set_scrollable_fit2(list, LV_FIT_PARENT, LV_FIT_TIGHT);
-    }
-    else if(layout == LV_LAYOUT_ROW_MID || layout == LV_LAYOUT_ROW_TOP || layout == LV_LAYOUT_ROW_BOTTOM) {
-        lv_page_set_scrollable_fit2(list, LV_FIT_TIGHT, LV_FIT_TIGHT);
-        lv_cont_set_fit2(list, LV_FIT_NONE, LV_FIT_TIGHT);
-    }
-
-    lv_page_set_scrl_layout(list, layout);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of a list element
- * @param btn pointer to list element
- * @return pointer to the text
- */
-const char * lv_list_get_btn_text(const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, "lv_btn");
-
-    lv_obj_t * label = lv_list_get_btn_label(btn);
-    if(label == NULL) return "";
-    return lv_label_get_text(label);
-}
-
-/**
- * Get the label object from a list element
- * @param btn pointer to a list element (button)
- * @return pointer to the label from the list element or NULL if not found
- */
-lv_obj_t * lv_list_get_btn_label(const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, "lv_btn");
-
-    lv_obj_t * label = lv_obj_get_child_back(btn, NULL);
-    if(label == NULL) return NULL;
-
-    while(lv_list_is_list_label(label) == false) {
-        label = lv_obj_get_child_back(btn, label);
-        if(label == NULL) break;
-    }
-
-    return label;
-}
-
-/**
- * Get the image object from a list element
- * @param btn pointer to a list element (button)
- * @return pointer to the image from the list element or NULL if not found
- */
-lv_obj_t * lv_list_get_btn_img(const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, "lv_btn");
-
-#if LV_USE_IMG != 0
-    lv_obj_t * img = lv_obj_get_child_back(btn, NULL);
-    if(img == NULL) return NULL;
-
-    while(lv_list_is_list_img(img) == false) {
-        img = lv_obj_get_child_back(btn, img);
-        if(img == NULL) break;
-    }
-
-    return img;
-#else
-    return NULL;
-#endif
-}
-
-/**
- * Get the previous button from list. (Starts from the bottom button)
- * @param list pointer to a list object
- * @param prev_btn pointer to button. Search the previous before it.
- * @return pointer to the previous button or NULL when no more buttons
- */
-lv_obj_t * lv_list_get_prev_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    /* Not a good practice but user can add/create objects to the lists manually.
-     * When getting the next button try to be sure that it is at least a button */
-
-    lv_obj_t * btn;
-    lv_obj_t * scrl = lv_page_get_scrollable(list);
-
-    btn = lv_obj_get_child(scrl, prev_btn);
-    if(btn == NULL) return NULL;
-
-    while(lv_list_is_list_btn(btn) == false) {
-        btn = lv_obj_get_child(scrl, btn);
-        if(btn == NULL) break;
-    }
-
-    return btn;
-}
-
-/**
- * Get the next button from list. (Starts from the top button)
- * @param list pointer to a list object
- * @param prev_btn pointer to button. Search the next after it.
- * @return pointer to the next button or NULL when no more buttons
- */
-lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    /* Not a good practice but user can add/create objects to the lists manually.
-     * When getting the next button try to be sure that it is at least a button */
-
-    lv_obj_t * btn;
-    lv_obj_t * scrl = lv_page_get_scrollable(list);
-
-    btn = lv_obj_get_child_back(scrl, prev_btn);
-    if(btn == NULL) return NULL;
-
-    while(lv_list_is_list_btn(btn) == false) {
-        btn = lv_obj_get_child_back(scrl, btn);
-        if(btn == NULL) break;
-    }
-
-    return btn;
-}
-
-/**
- * Get the index of the button in the list
- * @param list pointer to a list object. If NULL, assumes btn is part of a list.
- * @param btn pointer to a list element (button)
- * @return the index of the button in the list, or -1 of the button not in this list
- */
-int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
-{
-    LV_ASSERT_OBJ(btn, "lv_btn");
-
-    int index = 0;
-    if(list == NULL) {
-        /* no list provided, assuming btn is part of a list */
-        list = lv_obj_get_parent(lv_obj_get_parent(btn));
-    }
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    lv_obj_t * e = lv_list_get_next_btn(list, NULL);
-    while(e != NULL) {
-        if(e == btn) {
-            return index;
-        }
-        index++;
-        e = lv_list_get_next_btn(list, e);
-    }
-    return -1;
-}
-
-/**
- * Get the number of buttons in the list
- * @param list pointer to a list object
- * @return the number of buttons in the list
- */
-uint16_t lv_list_get_size(const lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    uint16_t size = 0;
-    lv_obj_t * btn = lv_list_get_next_btn(list, NULL);
-    while(btn) {
-        size++;
-        btn = lv_list_get_next_btn(list, btn);
-    }
-    return size;
-}
-
-#if LV_USE_GROUP
-/**
- * Get the currently selected button
- * @param list pointer to a list object
- * @return pointer to the selected button
- */
-lv_obj_t * lv_list_get_btn_selected(const lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-    return ext->act_sel_btn;
-}
-#endif
-
-/**
- * Get layout of a list
- * @param list pointer to a list object
- * @return layout of the list object
- */
-lv_layout_t lv_list_get_layout(lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    return lv_page_get_scrl_layout(list);
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Move the list elements up by one
- * @param list pointer a to list object
- */
-void lv_list_up(const lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    /*Search the first list element which 'y' coordinate is below the parent
-     * and position the list to show this element on the bottom*/
-    lv_obj_t * scrl = lv_page_get_scrollable(list);
-    lv_obj_t * e;
-    lv_obj_t * e_prev = NULL;
-
-    e                 = lv_list_get_prev_btn(list, NULL);
-    while(e != NULL) {
-        if(e->coords.y2 <= list->coords.y2) {
-            if(e_prev != NULL) {
-                lv_coord_t new_y = lv_obj_get_height(list) - (lv_obj_get_y(e_prev) + lv_obj_get_height(e_prev));
-                if(lv_list_get_anim_time(list) == 0) {
-                    lv_obj_set_y(scrl, new_y);
-                }
-                else {
-#if LV_USE_ANIMATION
-                    lv_anim_t a;
-                    lv_anim_init(&a);
-                    lv_anim_set_var(&a, scrl);
-                    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-                    lv_anim_set_values(&a, lv_obj_get_y(scrl), new_y);
-                    lv_anim_set_time(&a, LV_LIST_DEF_ANIM_TIME);
-                    lv_anim_start(&a);
-#endif
-                }
-            }
-            break;
-        }
-        e_prev = e;
-        e      = lv_list_get_prev_btn(list, e);
-    }
-}
-
-/**
- * Move the list elements down by one
- * @param list pointer to a list object
- */
-void lv_list_down(const lv_obj_t * list)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    /*Search the first list element which 'y' coordinate is above the parent
-     * and position the list to show this element on the top*/
-    lv_obj_t * scrl = lv_page_get_scrollable(list);
-    lv_obj_t * e;
-    e = lv_list_get_prev_btn(list, NULL);
-    while(e != NULL) {
-        if(e->coords.y1 < list->coords.y1) {
-            lv_coord_t new_y = -lv_obj_get_y(e);
-            if(lv_list_get_anim_time(list) == 0) {
-                lv_obj_set_y(scrl, new_y);
-            }
-            else {
-#if LV_USE_ANIMATION
-                lv_anim_t a;
-                lv_anim_init(&a);
-                lv_anim_set_var(&a, scrl);
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-                lv_anim_set_values(&a, lv_obj_get_y(scrl), new_y);
-                lv_anim_set_time(&a, LV_LIST_DEF_ANIM_TIME);
-                lv_anim_start(&a);
-#endif
-            }
-            break;
-        }
-        e = lv_list_get_prev_btn(list, e);
-    }
-}
-
-/**
- * Focus on a list button. It ensures that the button will be visible on the list.
- * @param btn pointer to a list button to focus
- * @param anim_en LV_ANIM_ON: scroll with animation, LV_ANOM_OFF: without animation
- */
-void lv_list_focus(const lv_obj_t * btn, lv_anim_enable_t anim)
-{
-    LV_ASSERT_OBJ(btn, "");
-
-#if LV_USE_ANIMATION == 0
-    anim = false;
-#endif
-
-    lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));
-
-    lv_page_focus(list, btn, anim == LV_ANIM_OFF ? 0 : lv_list_get_anim_time(list));
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the list
- * @param list pointer to a list object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_list_get_style(list, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_page_signal(list, sign, param);
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_page_signal(list, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_PRESSING ||
-       sign == LV_SIGNAL_LONG_PRESS || sign == LV_SIGNAL_LONG_PRESS_REP) {
-#if LV_USE_GROUP
-        /*If pressed/released etc by a KEYPAD or ENCODER delegate signal and events to the button*/
-        lv_indev_t * indev         = lv_indev_get_act();
-        lv_indev_type_t indev_type = lv_indev_get_type(indev);
-        if(indev_type == LV_INDEV_TYPE_KEYPAD ||
-           (indev_type == LV_INDEV_TYPE_ENCODER && lv_group_get_editing(lv_obj_get_group(list)))) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-
-            /*The page receives the key presses so the events should be propagated to the selected
-             * button*/
-            if(ext->act_sel_btn) {
-                res = lv_signal_send(ext->act_sel_btn, sign, param);
-                if(res != LV_RES_OK) return res;
-                if(sign == LV_SIGNAL_PRESSED) {
-                    res = lv_event_send(ext->act_sel_btn, LV_EVENT_PRESSED, NULL);
-                    if(res != LV_RES_OK) return res;
-                }
-                else if(sign == LV_SIGNAL_PRESSING) {
-                    res = lv_event_send(ext->act_sel_btn, LV_EVENT_PRESSING, NULL);
-                    if(res != LV_RES_OK) return res;
-                }
-                else if(sign == LV_SIGNAL_LONG_PRESS) {
-                    res = lv_event_send(ext->act_sel_btn, LV_EVENT_LONG_PRESSED, NULL);
-                    if(res != LV_RES_OK) return res;
-                }
-                else if(sign == LV_SIGNAL_LONG_PRESS_REP) {
-                    res = lv_event_send(ext->act_sel_btn, LV_EVENT_LONG_PRESSED_REPEAT, NULL);
-                    if(res != LV_RES_OK) return res;
-                }
-                else if(sign == LV_SIGNAL_RELEASED) {
-                    if(indev->proc.long_pr_sent == 0) {
-                        res = lv_event_send(ext->act_sel_btn, LV_EVENT_SHORT_CLICKED, NULL);
-                        if(res != LV_RES_OK) return res;
-                    }
-                    if(lv_indev_is_scrolling(indev) == false) {
-                        res = lv_event_send(ext->act_sel_btn, LV_EVENT_CLICKED, NULL);
-                        if(res != LV_RES_OK) return res;
-                    }
-
-                    res = lv_event_send(ext->act_sel_btn, LV_EVENT_RELEASED, NULL);
-                    if(res != LV_RES_OK) return res;
-                }
-            }
-        }
-#endif
-    }
-    else if(sign == LV_SIGNAL_FOCUS) {
-
-#if LV_USE_GROUP
-        lv_indev_type_t indev_type = lv_indev_get_type(lv_indev_get_act());
-        /*With ENCODER focus the button only in edit mode*/
-        lv_group_t * g = lv_obj_get_group(list);
-        if((indev_type == LV_INDEV_TYPE_KEYPAD) ||
-           (indev_type == LV_INDEV_TYPE_ENCODER && lv_group_get_editing(g))) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-            /* Select the last used button, or use the first no last button */
-            if(ext->last_sel_btn) lv_list_focus_btn(list, ext->last_sel_btn);
-            else lv_list_focus_btn(list, lv_list_get_next_btn(list, NULL));
-        }
-        if(indev_type == LV_INDEV_TYPE_ENCODER && lv_group_get_editing(g) == false) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-            if(ext->act_sel_btn) lv_obj_clear_state(ext->act_sel_btn, LV_STATE_PRESSED);
-            if(ext->last_sel_btn) lv_obj_clear_state(ext->last_sel_btn, LV_STATE_PRESSED);
-        }
-#endif
-    }
-    else if(sign == LV_SIGNAL_DEFOCUS) {
-
-#if LV_USE_GROUP
-        /*De-select the selected btn*/
-        lv_list_focus_btn(list, NULL);
-        lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-        ext->act_sel_btn   = NULL;
-#endif
-    }
-    else if(sign == LV_SIGNAL_GET_EDITABLE) {
-#if LV_USE_GROUP
-        bool * editable = (bool *)param;
-        *editable       = true;
-#endif
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-
-#if LV_USE_GROUP
-        char c = *((char *)param);
-        if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-            /*If there is a valid selected button the make the previous selected*/
-            if(ext->act_sel_btn) {
-                lv_obj_t * btn_prev = lv_list_get_next_btn(list, ext->act_sel_btn);
-                if(btn_prev) lv_list_focus_btn(list, btn_prev);
-            }
-            /*If there is no selected button the make the first selected*/
-            else {
-                lv_obj_t * btn = lv_list_get_next_btn(list, NULL);
-                if(btn)
-                    lv_list_focus_btn(list,
-                                      btn); /*If there are no buttons on the list then there is no first button*/
-            }
-        }
-        else if(c == LV_KEY_LEFT || c == LV_KEY_UP) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-            /*If there is a valid selected button the make the next selected*/
-            if(ext->act_sel_btn != NULL) {
-                lv_obj_t * btn_next = lv_list_get_prev_btn(list, ext->act_sel_btn);
-                if(btn_next) lv_list_focus_btn(list, btn_next);
-            }
-            /*If there is no selected button the make the first selected*/
-            else {
-                lv_obj_t * btn = lv_list_get_next_btn(list, NULL);
-                if(btn) lv_list_focus_btn(list, btn);
-            }
-        }
-        else if(c == LV_KEY_ESC) {
-            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-            /* Handle ESC/Cancel event */
-            res = lv_event_send(ext->act_sel_btn, LV_EVENT_CANCEL, NULL);
-        }
-#endif
-    }
-    return res;
-}
-
-/**
- * Signal function of the list buttons
- * @param btn pointer to a button on the list
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_btn_signal(btn, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    if((sign == LV_SIGNAL_COORD_CHG && (lv_obj_get_width(btn) != lv_area_get_width(param) ||
-                                        lv_obj_get_height(btn) != lv_area_get_height(param))) ||
-       sign == LV_SIGNAL_STYLE_CHG) {
-        lv_obj_t * label = lv_list_get_btn_label(btn);
-        if(label) {
-            const lv_font_t * font = lv_obj_get_style_text_font(label, LV_LABEL_PART_MAIN);
-            lv_coord_t font_h = lv_font_get_line_height(font);
-            if(lv_obj_get_base_dir(btn) == LV_BIDI_DIR_RTL) {
-                lv_coord_t pad = lv_obj_get_style_pad_left(btn, LV_BTN_PART_MAIN);
-                lv_obj_set_size(label, label->coords.x2 - btn->coords.x1 - pad, font_h);
-            }
-            else {
-                lv_coord_t pad = lv_obj_get_style_pad_right(btn, LV_BTN_PART_MAIN);
-                lv_obj_set_size(label, btn->coords.x2 - label->coords.x1 - pad + 1, font_h);
-            }
-        }
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
-            lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));
-            lv_list_focus_btn(list, btn);
-#if LV_USE_GROUP
-            if(lv_obj_get_group(list)) {
-                lv_group_focus_obj(list);
-            }
-#endif
-        }
-    }
-    else if(sign == LV_SIGNAL_CLEANUP) {
-#if LV_USE_GROUP
-        lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));
-        lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-        lv_obj_t * sel  = lv_list_get_btn_selected(list);
-        if(sel == btn) lv_list_focus_btn(list, lv_list_get_next_btn(list, btn));
-        if(ext->last_sel_btn == btn) ext->last_sel_btn = NULL;
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param list pointer the object
- * @param part the part from `lv_page_list_t`. (LV_LIST_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_list_get_style(lv_obj_t * list, uint8_t part)
-{
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
-
-    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_LIST_PART_BG:
-            style_dsc_p = &list->style_list;
-            break;
-        case LV_LIST_PART_SCROLLABLE:
-            style_dsc_p = &ext->page.scrl->style_list;
-            break;
-        case LV_LIST_PART_SCROLLBAR:
-            style_dsc_p = &ext->page.scrlbar.style;
-            break;
-#if LV_USE_ANIMATION
-        case LV_LIST_PART_EDGE_FLASH:
-            style_dsc_p = &ext->page.edge_flash.style;
-            break;
-#endif
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * Check if this is really a list button or another object.
- * @param list_btn List button
- */
-static bool lv_list_is_list_btn(lv_obj_t * list_btn)
-{
-    lv_obj_type_t type;
-
-    lv_obj_get_type(list_btn, &type);
-    uint8_t cnt;
-    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
-        if(type.type[cnt] == NULL) break;
-        if(!strcmp(type.type[cnt], "lv_btn")) return true;
-    }
-    return false;
-}
-
-/**
- * Check if this is really a list label or another object.
- * @param list_label List label
- */
-static bool lv_list_is_list_label(lv_obj_t * list_label)
-{
-    lv_obj_type_t type;
-
-    lv_obj_get_type(list_label, &type);
-    uint8_t cnt;
-    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
-        if(type.type[cnt] == NULL) break;
-        if(!strcmp(type.type[cnt], "lv_label")) return true;
-    }
-    return false;
-}
-
-/**
- * Check if this is really a list image or another object.
- * @param list_image List image
- */
-static bool lv_list_is_list_img(lv_obj_t * list_img)
-{
-    lv_obj_type_t type;
-
-    lv_obj_get_type(list_img, &type);
-    uint8_t cnt;
-    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
-        if(type.type[cnt] == NULL) break;
-        if(!strcmp(type.type[cnt], "lv_img")) return true;
-    }
-    return false;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_list.h b/src/lv_widgets/lv_list.h
deleted file mode 100644
index 92e521a14..000000000
--- a/src/lv_widgets/lv_list.h
+++ /dev/null
@@ -1,311 +0,0 @@
-/**
- * @file lv_list.h
- *
- */
-
-#ifndef LV_LIST_H
-#define LV_LIST_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_LIST != 0
-
-/*Testing of dependencies*/
-#if LV_USE_PAGE == 0
-#error "lv_list: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE  1) "
-#endif
-
-#if LV_USE_BTN == 0
-#error "lv_list: lv_btn is required. Enable it in lv_conf.h (LV_USE_BTN  1) "
-#endif
-
-#if LV_USE_LABEL == 0
-#error "lv_list: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "lv_page.h"
-#include "lv_btn.h"
-#include "lv_label.h"
-#include "lv_img.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of list*/
-typedef struct {
-    lv_page_ext_t page; /*Ext. of ancestor*/
-    /*New data for this type */
-
-#if LV_USE_GROUP
-    lv_obj_t * last_sel_btn;     /* The last selected button. It will be reverted when the list is focused again */
-#endif
-    lv_obj_t * act_sel_btn; /* The button is currently being selected*/
-} lv_list_ext_t;
-
-/** List styles. */
-enum {
-    LV_LIST_PART_BG = LV_PAGE_PART_BG, /**< List background style */
-    LV_LIST_PART_SCROLLBAR = LV_PAGE_PART_SCROLLBAR, /**< List scrollbar style. */
-    LV_LIST_PART_EDGE_FLASH = LV_PAGE_PART_EDGE_FLASH, /**< List edge flash style. */
-    _LV_LIST_PART_VIRTUAL_LAST = _LV_PAGE_PART_VIRTUAL_LAST,
-    LV_LIST_PART_SCROLLABLE = LV_PAGE_PART_SCROLLABLE, /**< List scrollable area style. */
-    _LV_LIST_PART_REAL_LAST = _LV_PAGE_PART_REAL_LAST,
-};
-typedef uint8_t lv_list_style_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a list objects
- * @param par pointer to an object, it will be the parent of the new list
- * @param copy pointer to a list object, if not NULL then the new object will be copied from it
- * @return pointer to the created list
- */
-lv_obj_t * lv_list_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param list pointer to an object
- */
-void lv_list_clean(lv_obj_t * list);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add a list element to the list
- * @param list pointer to list object
- * @param img_fn file name of an image before the text (NULL if unused)
- * @param txt text of the list element (NULL if unused)
- * @return pointer to the new list element which can be customized (a button)
- */
-lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * txt);
-
-/**
- * Remove the index of the button in the list
- * @param list pointer to a list object
- * @param index pointer to a the button's index in the list, index must be 0 <= index <
- * lv_list_ext_t.size
- * @return true: successfully deleted
- */
-bool lv_list_remove(const lv_obj_t * list, uint16_t index);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Make a button selected
- * @param list pointer to a list object
- * @param btn pointer to a button to select
- *            NULL to not select any buttons
- */
-void lv_list_focus_btn(lv_obj_t * list, lv_obj_t * btn);
-
-/**
- * Set the scroll bar mode of a list
- * @param list pointer to a list object
- * @param sb_mode the new mode from 'lv_page_sb_mode_t' enum
- */
-static inline void lv_list_set_scrollbar_mode(lv_obj_t * list, lv_scrollbar_mode_t mode)
-{
-    lv_page_set_scrollbar_mode(list, mode);
-}
-
-/**
- * Enable the scroll propagation feature. If enabled then the List will move its parent if there is
- * no more space to scroll.
- * @param list pointer to a List
- * @param en true or false to enable/disable scroll propagation
- */
-static inline void lv_list_set_scroll_propagation(lv_obj_t * list, bool en)
-{
-    lv_page_set_scroll_propagation(list, en);
-}
-
-/**
- * Enable the edge flash effect. (Show an arc when the an edge is reached)
- * @param list pointer to a List
- * @param en true or false to enable/disable end flash
- */
-static inline void lv_list_set_edge_flash(lv_obj_t * list, bool en)
-{
-    lv_page_set_edge_flash(list, en);
-}
-
-/**
- * Set scroll animation duration on 'list_up()' 'list_down()' 'list_focus()'
- * @param list pointer to a list object
- * @param anim_time duration of animation [ms]
- */
-static inline void lv_list_set_anim_time(lv_obj_t * list, uint16_t anim_time)
-{
-    lv_page_set_anim_time(list, anim_time);
-}
-
-/**
- * Set layout of a list
- * @param list pointer to a list object
- * @param layout which layout should be used
- */
-void lv_list_set_layout(lv_obj_t * list, lv_layout_t layout);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of a list element
- * @param btn pointer to list element
- * @return pointer to the text
- */
-const char * lv_list_get_btn_text(const lv_obj_t * btn);
-/**
- * Get the label object from a list element
- * @param btn pointer to a list element (button)
- * @return pointer to the label from the list element or NULL if not found
- */
-lv_obj_t * lv_list_get_btn_label(const lv_obj_t * btn);
-
-/**
- * Get the image object from a list element
- * @param btn pointer to a list element (button)
- * @return pointer to the image from the list element or NULL if not found
- */
-lv_obj_t * lv_list_get_btn_img(const lv_obj_t * btn);
-
-/**
- * Get the next button from list. (Starts from the bottom button)
- * @param list pointer to a list object
- * @param prev_btn pointer to button. Search the next after it.
- * @return pointer to the next button or NULL when no more buttons
- */
-lv_obj_t * lv_list_get_prev_btn(const lv_obj_t * list, lv_obj_t * prev_btn);
-
-/**
- * Get the previous button from list. (Starts from the top button)
- * @param list pointer to a list object
- * @param prev_btn pointer to button. Search the previous before it.
- * @return pointer to the previous button or NULL when no more buttons
- */
-lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn);
-
-/**
- * Get the index of the button in the list
- * @param list pointer to a list object. If NULL, assumes btn is part of a list.
- * @param btn pointer to a list element (button)
- * @return the index of the button in the list, or -1 of the button not in this list
- */
-int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn);
-
-/**
- * Get the number of buttons in the list
- * @param list pointer to a list object
- * @return the number of buttons in the list
- */
-uint16_t lv_list_get_size(const lv_obj_t * list);
-
-#if LV_USE_GROUP
-/**
- * Get the currently selected button. Can be used while navigating in the list with a keypad.
- * @param list pointer to a list object
- * @return pointer to the selected button
- */
-lv_obj_t * lv_list_get_btn_selected(const lv_obj_t * list);
-#endif
-
-/**
- * Get layout of a list
- * @param list pointer to a list object
- * @return layout of the list object
- */
-lv_layout_t lv_list_get_layout(lv_obj_t * list);
-
-/**
- * Get the scroll bar mode of a list
- * @param list pointer to a list object
- * @return scrollbar mode from 'lv_scrollbar_mode_t' enum
- */
-static inline lv_scrollbar_mode_t lv_list_get_scrollbar_mode(const lv_obj_t * list)
-{
-    return lv_page_get_scrollbar_mode(list);
-}
-
-/**
- * Get the scroll propagation property
- * @param list pointer to a List
- * @return true or false
- */
-static inline bool lv_list_get_scroll_propagation(lv_obj_t * list)
-{
-    return lv_page_get_scroll_propagation(list);
-}
-
-/**
- * Get the scroll propagation property
- * @param list pointer to a List
- * @return true or false
- */
-static inline bool lv_list_get_edge_flash(lv_obj_t * list)
-{
-    return lv_page_get_edge_flash(list);
-}
-
-/**
- * Get scroll animation duration
- * @param list pointer to a list object
- * @return duration of animation [ms]
- */
-static inline uint16_t lv_list_get_anim_time(const lv_obj_t * list)
-{
-    return lv_page_get_anim_time(list);
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Move the list elements up by one
- * @param list pointer a to list object
- */
-void lv_list_up(const lv_obj_t * list);
-/**
- * Move the list elements down by one
- * @param list pointer to a list object
- */
-void lv_list_down(const lv_obj_t * list);
-
-/**
- * Focus on a list button. It ensures that the button will be visible on the list.
- * @param btn pointer to a list button to focus
- * @param anim LV_ANOM_ON: scroll with animation, LV_ANIM_OFF: without animation
- */
-void lv_list_focus(const lv_obj_t * btn, lv_anim_enable_t anim);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_LIST*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_LIST_H*/
diff --git a/src/lv_widgets/lv_msgbox.c b/src/lv_widgets/lv_msgbox.c
deleted file mode 100644
index 9448bec58..000000000
--- a/src/lv_widgets/lv_msgbox.c
+++ /dev/null
@@ -1,606 +0,0 @@
-/**
- * @file lv_msgbox.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_msgbox.h"
-#if LV_USE_MSGBOX != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_core/lv_group.h"
-#include "../lv_core/lv_disp.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_anim.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_msgbox"
-
-#if LV_USE_ANIMATION
-    #ifndef LV_MSGBOX_CLOSE_ANIM_TIME
-        #define LV_MSGBOX_CLOSE_ANIM_TIME 200 /*List close animation time)  */
-    #endif
-#else
-    #undef LV_MSGBOX_CLOSE_ANIM_TIME
-    #define LV_MSGBOX_CLOSE_ANIM_TIME 0 /*No animations*/
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_msgbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param);
-static void mbox_realign(lv_obj_t * mbox);
-static lv_style_list_t * lv_msgbox_get_style(lv_obj_t * mbox, uint8_t part);
-#if LV_USE_ANIMATION
-    static void lv_msgbox_close_ready_cb(lv_anim_t * a);
-#endif
-static void lv_msgbox_default_event_cb(lv_obj_t * mbox, lv_event_t event);
-static void lv_msgbox_btnm_event_cb(lv_obj_t * btnm, lv_event_t event);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a message box objects
- * @param par pointer to an object, it will be the parent of the new message box
- * @param copy pointer to a message box object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created message box
- */
-lv_obj_t * lv_msgbox_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("message box create started");
-
-    /*Create the ancestor message box*/
-    lv_obj_t * mbox = lv_cont_create(par, copy);
-    LV_ASSERT_MEM(mbox);
-    if(mbox == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(mbox);
-
-    /*Allocate the message box type specific extended data*/
-    lv_msgbox_ext_t * ext = lv_obj_allocate_ext_attr(mbox, sizeof(lv_msgbox_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(mbox);
-        return NULL;
-    }
-
-    ext->text = NULL;
-    ext->btnm = NULL;
-#if LV_USE_ANIMATION
-    ext->anim_time = LV_MSGBOX_CLOSE_ANIM_TIME;
-#endif
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(mbox, lv_msgbox_signal);
-
-    /*Init the new message box message box*/
-    if(copy == NULL) {
-        ext->text = lv_label_create(mbox, NULL);
-        lv_label_set_align(ext->text, LV_LABEL_ALIGN_CENTER);
-        lv_label_set_long_mode(ext->text, LV_LABEL_LONG_BREAK);
-        lv_label_set_text(ext->text, "Message");
-
-        lv_cont_set_layout(mbox, LV_LAYOUT_COLUMN_MID);
-        lv_cont_set_fit2(mbox, LV_FIT_NONE, LV_FIT_TIGHT);
-        lv_coord_t fit_w = lv_obj_get_width_fit(par);
-        if(lv_disp_get_size_category(NULL) <= LV_DISP_SIZE_SMALL) {
-            lv_obj_set_width(mbox, fit_w);
-        }
-        else {
-            lv_obj_set_width(mbox, LV_MATH_MIN(fit_w, LV_DPX(400)));
-        }
-        lv_obj_align(mbox, NULL, LV_ALIGN_CENTER, 0, 0);
-        lv_obj_set_event_cb(mbox, lv_msgbox_default_event_cb);
-
-        /*Set the default styles*/
-        lv_theme_apply(mbox, LV_THEME_MSGBOX);
-
-    }
-    /*Copy an existing message box*/
-    else {
-        lv_msgbox_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-
-        ext->text = lv_label_create(mbox, copy_ext->text);
-
-        /*Copy the buttons and the label on them*/
-        if(copy_ext->btnm) ext->btnm = lv_btnmatrix_create(mbox, copy_ext->btnm);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(mbox, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("message box created");
-
-    return mbox;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add button to the message box
- * @param mbox pointer to message box object
- * @param btn_map button descriptor (button matrix map).
- *                E.g.  a const char *txt[] = {"ok", "close", ""} (Can not be local variable)
- */
-void lv_msgbox_add_btns(lv_obj_t * mbox, const char * btn_map[])
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-    LV_ASSERT_NULL(btn_map);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-
-    /*Create a button matrix if not exists yet*/
-    if(ext->btnm == NULL) {
-        ext->btnm = lv_btnmatrix_create(mbox, NULL);
-
-        lv_theme_apply(mbox, LV_THEME_MSGBOX_BTNS);
-    }
-
-    lv_btnmatrix_set_map(ext->btnm, btn_map);
-    lv_btnmatrix_set_btn_ctrl_all(ext->btnm, LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
-    lv_obj_set_event_cb(ext->btnm, lv_msgbox_btnm_event_cb);
-
-    if(lv_obj_is_focused(mbox)) {
-        lv_state_t state = lv_obj_get_state(mbox, LV_MSGBOX_PART_BG);
-        if(state & LV_STATE_EDITED) {
-            lv_obj_set_state(ext->btnm, LV_STATE_FOCUSED | LV_STATE_EDITED);
-        }
-        else {
-            lv_obj_set_state(ext->btnm, LV_STATE_FOCUSED);
-        }
-
-        lv_btnmatrix_set_focused_btn(ext->btnm, 0);
-    }
-
-    mbox_realign(mbox);
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the text of the message box
- * @param mbox pointer to a message box
- * @param txt a '\0' terminated character string which will be the message box text
- */
-void lv_msgbox_set_text(lv_obj_t * mbox, const char * txt)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-    LV_ASSERT_STR(txt);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    lv_label_set_text(ext->text, txt);
-
-    mbox_realign(mbox);
-}
-
-/**
- * Set animation duration
- * @param mbox pointer to a message box object
- * @param anim_time animation length in  milliseconds (0: no animation)
- */
-void lv_msgbox_set_anim_time(lv_obj_t * mbox, uint16_t anim_time)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    anim_time           = 0;
-    ext->anim_time      = anim_time;
-#else
-    (void)mbox;
-    (void)anim_time;
-#endif
-}
-
-/**
- * Automatically delete the message box after a given time
- * @param mbox pointer to a message box object
- * @param delay a time (in milliseconds) to wait before delete the message box
- */
-void lv_msgbox_start_auto_close(lv_obj_t * mbox, uint16_t delay)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    if(lv_msgbox_get_anim_time(mbox) != 0) {
-        /*Add shrinking animations*/
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, mbox);
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_height);
-        lv_anim_set_values(&a, lv_obj_get_height(mbox), 0);
-        lv_anim_set_time(&a, lv_msgbox_get_anim_time(mbox));
-        lv_anim_set_delay(&a, delay);
-        lv_anim_start(&a);
-
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_width);
-        lv_anim_set_values(&a, lv_obj_get_width(mbox), 0);
-        lv_anim_set_ready_cb(&a, lv_msgbox_close_ready_cb);
-        lv_anim_start(&a);
-
-        /*Disable fit to let shrinking work*/
-        lv_cont_set_fit(mbox, LV_FIT_NONE);
-    }
-    else {
-        /*Create an animation to delete the mbox `delay` ms later*/
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, mbox);
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)NULL);
-        lv_anim_set_values(&a, 0, 1);
-        lv_anim_set_ready_cb(&a, lv_msgbox_close_ready_cb);
-        lv_anim_set_time(&a, lv_msgbox_get_anim_time(mbox));
-        lv_anim_set_delay(&a, delay);
-        lv_anim_start(&a);
-    }
-#else
-    (void)delay; /*Unused*/
-    lv_obj_del(mbox);
-#endif
-}
-
-/**
- * Stop the auto. closing of message box
- * @param mbox pointer to a message box object
- */
-void lv_msgbox_stop_auto_close(lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_anim_del(mbox, NULL);
-#else
-    (void)mbox; /*Unused*/
-#endif
-}
-
-/**
- * Set whether recoloring is enabled
- * @param mbox pointer to message box object
- * @param en whether recoloring is enabled
- */
-void lv_msgbox_set_recolor(lv_obj_t * mbox, bool en)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-
-    if(ext->btnm) lv_btnmatrix_set_recolor(ext->btnm, en);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of the message box
- * @param mbox pointer to a message box object
- * @return pointer to the text of the message box
- */
-const char * lv_msgbox_get_text(const lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-
-    return lv_label_get_text(ext->text);
-}
-
-/**
- * Get the index of the lastly "activated" button by the user (pressed, released etc)
- * Useful in the the `event_cb`.
- * @param mbox pointer to message box object
- * @return  index of the last released button (LV_BTNMATRIX_BTN_NONE: if unset)
- */
-uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    if(ext->btnm == NULL) return LV_BTNMATRIX_BTN_NONE;
-
-    uint16_t id = lv_btnmatrix_get_active_btn(ext->btnm);
-    if(id == LV_BTNMATRIX_BTN_NONE) {
-        id = lv_btnmatrix_get_focused_btn(ext->btnm);
-    }
-
-    return id;
-}
-
-/**
- * Get the text of the lastly "activated" button by the user (pressed, released etc)
- * Useful in the the `event_cb`.
- * @param mbox pointer to message box object
- * @return text of the last released button (NULL: if unset)
- */
-const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    if(ext->btnm)
-        return lv_btnmatrix_get_active_btn_text(ext->btnm);
-    else
-        return NULL;
-}
-
-/**
- * Get the animation duration (close animation time)
- * @param mbox pointer to a message box object
- * @return animation length in  milliseconds (0: no animation)
- */
-uint16_t lv_msgbox_get_anim_time(const lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    return ext->anim_time;
-#else
-    (void)mbox;
-    return 0;
-#endif
-}
-
-/**
- * Get whether recoloring is enabled
- * @param mbox pointer to a message box object
- * @return whether recoloring is enabled
- */
-bool lv_msgbox_get_recolor(const lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-
-    if(!ext->btnm) return false;
-
-    return lv_btnmatrix_get_recolor(ext->btnm);
-}
-
-/**
- * Get message box button matrix
- * @param mbox pointer to a message box object
- * @return pointer to button matrix object
- * @remarks return value will be NULL unless `lv_msgbox_add_btns` has been already called
- */
-lv_obj_t * lv_msgbox_get_btnmatrix(lv_obj_t * mbox)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    return ext->btnm;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the message box
- * @param mbox pointer to a message box object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_msgbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-#if LV_USE_GROUP
-    /*Translate LV_KEY_UP/DOWN to LV_KEY_LEFT/RIGHT */
-    char c_trans = 0;
-    if(sign == LV_SIGNAL_CONTROL) {
-        c_trans = *((char *)param);
-        if(c_trans == LV_KEY_DOWN) c_trans = LV_KEY_LEFT;
-        if(c_trans == LV_KEY_UP) c_trans = LV_KEY_RIGHT;
-
-        param = &c_trans;
-    }
-#endif
-
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_msgbox_get_style(mbox, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(mbox, sign, param);
-    }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        lv_get_state_info_t * info = param;
-        lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-        if(ext->btnm && info->part == LV_MSGBOX_PART_BTN_BG) {
-            info->result = lv_obj_get_state(ext->btnm, LV_BTNMATRIX_PART_BG);
-        }
-        else if(ext->btnm && info->part == LV_MSGBOX_PART_BTN) {
-            info->result = lv_obj_get_state(ext->btnm, LV_BTNMATRIX_PART_BTN);
-        }
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(mbox, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    if(sign == LV_SIGNAL_COORD_CHG) {
-        if(lv_obj_get_width(mbox) != lv_area_get_width(param)) {
-            mbox_realign(mbox);
-        }
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        mbox_realign(mbox);
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        if(ext->btnm) {
-            uint32_t btn_id = lv_btnmatrix_get_focused_btn(ext->btnm);
-            if(btn_id != LV_BTNMATRIX_BTN_NONE) lv_event_send(mbox, LV_EVENT_VALUE_CHANGED, &btn_id);
-        }
-    }
-    else if(
-#if LV_USE_GROUP
-        sign == LV_SIGNAL_CONTROL || sign == LV_SIGNAL_GET_EDITABLE ||
-#endif
-        sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS) {
-        if(ext->btnm) {
-            ext->btnm->signal_cb(ext->btnm, sign, param);
-        }
-
-        /* The button matrix with ENCODER input supposes it's in a group but in this case it isn't
-         * (Only the message box's container) So so some actions here instead*/
-#if LV_USE_GROUP
-        if(sign == LV_SIGNAL_FOCUS) {
-            lv_indev_t * indev         = lv_indev_get_act();
-            lv_indev_type_t indev_type = lv_indev_get_type(indev);
-            if(indev_type == LV_INDEV_TYPE_ENCODER) {
-                /*In navigation mode don't select any button but in edit mode select the fist*/
-                if(lv_group_get_editing(lv_obj_get_group(mbox))) lv_btnmatrix_set_focused_btn(ext->btnm, 0);
-                else lv_btnmatrix_set_focused_btn(ext->btnm, LV_BTNMATRIX_BTN_NONE);
-            }
-        }
-
-        if(ext->btnm && (sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS)) {
-            lv_state_t state = lv_obj_get_state(mbox, LV_MSGBOX_PART_BG);
-            if(state & LV_STATE_FOCUSED) {
-                lv_obj_set_state(ext->btnm, LV_STATE_FOCUSED);
-            }
-            else {
-                lv_obj_clear_state(ext->btnm, LV_STATE_FOCUSED);
-
-            }
-            if(state & LV_STATE_EDITED) {
-                lv_obj_set_state(ext->btnm, LV_STATE_EDITED);
-            }
-            else {
-                lv_obj_clear_state(ext->btnm, LV_STATE_EDITED);
-
-            }
-        }
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param mbox pointer the object
- * @param part the part from `lv_msgbox_part_t`. (LV_MSGBOX_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_msgbox_get_style(lv_obj_t * mbox, uint8_t part)
-{
-    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
-
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_MSGBOX_PART_BG:
-            style_dsc_p = &mbox->style_list;
-            break;
-        case LV_MSGBOX_PART_BTN_BG:
-            style_dsc_p = ext->btnm ? lv_obj_get_style_list(ext->btnm, LV_BTNMATRIX_PART_BG) : NULL;
-            break;
-        case LV_MSGBOX_PART_BTN:
-            style_dsc_p = ext->btnm ? lv_obj_get_style_list(ext->btnm, LV_BTNMATRIX_PART_BTN) : NULL;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * Resize the button holder to fit
- * @param mbox pointer to message box object
- */
-static void mbox_realign(lv_obj_t * mbox)
-{
-    lv_msgbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
-
-    lv_coord_t w = lv_obj_get_width_fit(mbox);
-
-    if(ext->text) {
-        lv_obj_set_width(ext->text, w);
-    }
-
-    if(ext->btnm) {
-        lv_style_int_t bg_top = lv_obj_get_style_pad_top(mbox, LV_MSGBOX_PART_BTN_BG);
-        lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(mbox, LV_MSGBOX_PART_BTN_BG);
-        lv_style_int_t bg_inner = lv_obj_get_style_pad_inner(mbox, LV_MSGBOX_PART_BTN_BG);
-        lv_style_int_t btn_top = lv_obj_get_style_pad_top(mbox, LV_MSGBOX_PART_BTN);
-        lv_style_int_t btn_bottom = lv_obj_get_style_pad_bottom(mbox, LV_MSGBOX_PART_BTN);
-        const lv_font_t * font = lv_obj_get_style_text_font(mbox, LV_MSGBOX_PART_BTN);
-
-        uint16_t btnm_lines = 1;
-        const char ** btnm_map = lv_btnmatrix_get_map_array(ext->btnm);
-        uint16_t i;
-        for(i = 0; btnm_map[i][0] != '\0'; i++) {
-            if(btnm_map[i][0] == '\n') btnm_lines++;
-        }
-
-        lv_coord_t font_h = lv_font_get_line_height(font);
-        lv_coord_t btn_h = font_h + btn_top + btn_bottom;
-        lv_obj_set_size(ext->btnm, w, btn_h * btnm_lines + bg_inner * (btnm_lines - 1) + bg_top + bg_bottom);
-    }
-}
-
-#if LV_USE_ANIMATION
-static void lv_msgbox_close_ready_cb(lv_anim_t * a)
-{
-    lv_obj_del(a->var);
-}
-#endif
-
-static void lv_msgbox_default_event_cb(lv_obj_t * mbox, lv_event_t event)
-{
-    if(event != LV_EVENT_VALUE_CHANGED) return;
-
-    uint32_t btn_id = lv_msgbox_get_active_btn(mbox);
-    if(btn_id == LV_BTNMATRIX_BTN_NONE) return;
-
-    lv_msgbox_start_auto_close(mbox, 0);
-}
-
-static void lv_msgbox_btnm_event_cb(lv_obj_t * btnm, lv_event_t event)
-{
-    lv_obj_t * mbox = lv_obj_get_parent(btnm);
-
-    /*clang-format off*/
-    if(event == LV_EVENT_PRESSED || event == LV_EVENT_PRESSING || event == LV_EVENT_PRESS_LOST ||
-       event == LV_EVENT_RELEASED || event == LV_EVENT_SHORT_CLICKED || event == LV_EVENT_CLICKED ||
-       event == LV_EVENT_LONG_PRESSED || event == LV_EVENT_LONG_PRESSED_REPEAT ||
-       event == LV_EVENT_VALUE_CHANGED) {
-        lv_event_send(mbox, event, lv_event_get_data());
-    }
-    /*clang-format on*/
-}
-
-#endif
diff --git a/src/lv_widgets/lv_msgbox.h b/src/lv_widgets/lv_msgbox.h
deleted file mode 100644
index b9fde8a87..000000000
--- a/src/lv_widgets/lv_msgbox.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/**
- * @file lv_mbox.h
- *
- */
-
-#ifndef LV_MSGBOX_H
-#define LV_MSGBOX_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_MSGBOX != 0
-
-/*Testing of dependencies*/
-#if LV_USE_CONT == 0
-#error "lv_mbox: lv_cont is required. Enable it in lv_conf.h (LV_USE_CONT  1) "
-#endif
-
-#if LV_USE_BTNMATRIX == 0
-#error "lv_mbox: lv_btnm is required. Enable it in lv_conf.h (LV_USE_BTNMATRIX  1) "
-#endif
-
-#if LV_USE_LABEL == 0
-#error "lv_mbox: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "lv_cont.h"
-#include "lv_btnmatrix.h"
-#include "lv_label.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of message box*/
-typedef struct {
-    lv_cont_ext_t bg; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * text; /*Text of the message box*/
-    lv_obj_t * btnm; /*Button matrix for the buttons*/
-#if LV_USE_ANIMATION
-    uint16_t anim_time; /*Duration of close animation [ms] (0: no animation)*/
-#endif
-} lv_msgbox_ext_t;
-
-/** Message box styles. */
-enum {
-    LV_MSGBOX_PART_BG = LV_CONT_PART_MAIN,
-
-    LV_MSGBOX_PART_BTN_BG = _LV_CONT_PART_REAL_LAST,
-    LV_MSGBOX_PART_BTN,
-};
-typedef uint8_t lv_msgbox_style_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a message box objects
- * @param par pointer to an object, it will be the parent of the new message box
- * @param copy pointer to a message box object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created message box
- */
-lv_obj_t * lv_msgbox_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add button to the message box
- * @param mbox pointer to message box object
- * @param btn_map button descriptor (button matrix map).
- *                E.g.  a const char *txt[] = {"ok", "close", ""} (Can not be local variable)
- */
-void lv_msgbox_add_btns(lv_obj_t * mbox, const char * btn_mapaction[]);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the text of the message box
- * @param mbox pointer to a message box
- * @param txt a '\0' terminated character string which will be the message box text
- */
-void lv_msgbox_set_text(lv_obj_t * mbox, const char * txt);
-
-/**
- * Set animation duration
- * @param mbox pointer to a message box object
- * @param anim_time animation length in  milliseconds (0: no animation)
- */
-void lv_msgbox_set_anim_time(lv_obj_t * mbox, uint16_t anim_time);
-
-/**
- * Automatically delete the message box after a given time
- * @param mbox pointer to a message box object
- * @param delay a time (in milliseconds) to wait before delete the message box
- */
-void lv_msgbox_start_auto_close(lv_obj_t * mbox, uint16_t delay);
-
-/**
- * Stop the auto. closing of message box
- * @param mbox pointer to a message box object
- */
-void lv_msgbox_stop_auto_close(lv_obj_t * mbox);
-
-/**
- * Set whether recoloring is enabled. Must be called after `lv_msgbox_add_btns`.
- * @param mbox pointer to message box object
- * @param en whether recoloring is enabled
- */
-void lv_msgbox_set_recolor(lv_obj_t * mbox, bool en);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of the message box
- * @param mbox pointer to a message box object
- * @return pointer to the text of the message box
- */
-const char * lv_msgbox_get_text(const lv_obj_t * mbox);
-
-/**
- * Get the index of the lastly "activated" button by the user (pressed, released etc)
- * Useful in the the `event_cb`.
- * @param mbox pointer to message box object
- * @return  index of the last released button (LV_BTNMATRIX_BTN_NONE: if unset)
- */
-uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox);
-
-/**
- * Get the text of the lastly "activated" button by the user (pressed, released etc)
- * Useful in the the `event_cb`.
- * @param mbox pointer to message box object
- * @return text of the last released button (NULL: if unset)
- */
-const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox);
-
-/**
- * Get the animation duration (close animation time)
- * @param mbox pointer to a message box object
- * @return animation length in  milliseconds (0: no animation)
- */
-uint16_t lv_msgbox_get_anim_time(const lv_obj_t * mbox);
-
-/**
- * Get whether recoloring is enabled
- * @param mbox pointer to a message box object
- * @return whether recoloring is enabled
- */
-bool lv_msgbox_get_recolor(const lv_obj_t * mbox);
-
-/**
- * Get message box button matrix
- * @param mbox pointer to a message box object
- * @return pointer to button matrix object
- * @remarks return value will be NULL unless `lv_msgbox_add_btns` has been already called
- */
-lv_obj_t * lv_msgbox_get_btnmatrix(lv_obj_t * mbox);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_MSGBOX*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_MSGBOX_H*/
diff --git a/src/lv_widgets/lv_page.c b/src/lv_widgets/lv_page.c
deleted file mode 100644
index 8d6ea7a09..000000000
--- a/src/lv_widgets/lv_page.c
+++ /dev/null
@@ -1,1375 +0,0 @@
-/**
- * @file lv_page.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_widgets/lv_page.h"
-#if LV_USE_PAGE != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_core/lv_group.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_core/lv_refr.h"
-#include "../lv_misc/lv_anim.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_page"
-
-#define LV_PAGE_SB_MIN_SIZE (LV_DPI / 8)
-
-/*[ms] Scroll anim time on `lv_page_scroll_up/down/left/rigth`*/
-#define LV_PAGE_SCROLL_ANIM_TIME 200
-
-#define LV_PAGE_END_FLASH_SIZE (LV_DPI / 4)
-#define LV_PAGE_END_ANIM_TIME 300
-#define LV_PAGE_END_ANIM_WAIT_TIME 300
-
-#if LV_USE_ANIMATION == 0
-    #undef LV_PAGE_DEF_ANIM_TIME
-    #define LV_PAGE_DEF_ANIM_TIME 0 /*No animation*/
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void scrlbar_refresh(lv_obj_t * page);
-static void scrl_reposition(lv_obj_t * page);
-static lv_design_res_t lv_page_design(lv_obj_t * page, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_page_get_style(lv_obj_t * page, uint8_t part);
-static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
-static void scrl_def_event_cb(lv_obj_t * scrl, lv_event_t event);
-static void refr_ext_draw_pad(lv_obj_t * page);
-#if LV_USE_ANIMATION
-    static void edge_flash_anim(void * page, lv_anim_value_t v);
-    static void edge_flash_anim_end(lv_anim_t * a);
-    static void get_edge_flash_area(lv_obj_t * page, lv_area_t * area, lv_coord_t state);
-#endif
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_cb_t ancestor_design;
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a page objects
- * @param par pointer to an object, it will be the parent of the new page
- * @param copy pointer to a page object, if not NULL then the new object will be copied from it
- * @return pointer to the created page
- */
-lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("page create started");
-
-    /*Create the ancestor object*/
-    lv_obj_t * page = lv_cont_create(par, copy);
-    LV_ASSERT_MEM(page);
-    if(page == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(page);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(page);
-
-    /*Allocate the object type specific extended data*/
-    lv_page_ext_t * ext = lv_obj_allocate_ext_attr(page, sizeof(lv_page_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(page);
-        return NULL;
-    }
-
-    ext->scrl        = NULL;
-    lv_style_list_init(&ext->scrlbar.style);
-    ext->scrlbar.hor_draw = 0;
-    ext->scrlbar.ver_draw = 0;
-    ext->scrlbar.mode     = LV_SCROLLBAR_MODE_AUTO;
-#if LV_USE_ANIMATION
-    lv_style_list_init(&ext->edge_flash.style);
-    ext->edge_flash.enabled   = 0;
-    ext->edge_flash.bottom_ip = 0;
-    ext->edge_flash.top_ip    = 0;
-    ext->edge_flash.left_ip   = 0;
-    ext->edge_flash.right_ip  = 0;
-    ext->edge_flash.state     = 0;
-    ext->anim_time            = LV_PAGE_DEF_ANIM_TIME;
-#endif
-    ext->scroll_prop    = 0;
-    ext->scroll_prop_obj = NULL;
-
-    /*Init the new page object*/
-    if(copy == NULL) {
-        ext->scrl = lv_cont_create(page, NULL);
-        lv_obj_set_focus_parent(ext->scrl, true);
-        lv_obj_set_drag(ext->scrl, true);
-        lv_obj_set_drag_throw(ext->scrl, true);
-        lv_obj_add_protect(ext->scrl, LV_PROTECT_PARENT | LV_PROTECT_PRESS_LOST);
-        lv_cont_set_fit(ext->scrl, LV_FIT_MAX);
-        lv_obj_set_event_cb(ext->scrl, scrl_def_event_cb); /*Propagate some event to the background
-                                                              object by default for convenience */
-        lv_obj_set_signal_cb(ext->scrl, lv_page_scrollable_signal);
-
-        /* Add the signal function only if 'scrolling' is created
-        +         * because everything has to be ready before any signal is received*/
-        lv_obj_set_signal_cb(page, lv_page_signal);
-        lv_obj_set_design_cb(page, lv_page_design);
-
-
-        lv_page_set_scrollbar_mode(page, ext->scrlbar.mode);
-
-        lv_theme_apply(page, LV_THEME_PAGE);
-
-    }
-    else {
-        lv_page_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->scrl                = lv_cont_create(page, copy_ext->scrl);
-        lv_obj_set_signal_cb(ext->scrl, lv_page_scrollable_signal);
-
-        lv_style_list_copy(&ext->scrlbar.style, &copy_ext->scrlbar.style);
-#if LV_USE_ANIMATION
-        lv_style_list_copy(&ext->edge_flash.style, &copy_ext->edge_flash.style);
-#endif
-
-        /* Add the signal function only if 'scrolling' is created
-         * because everything has to be ready before any signal is received*/
-        lv_obj_set_signal_cb(page, lv_page_signal);
-        lv_obj_set_design_cb(page, lv_page_design);
-
-        lv_page_set_scrollbar_mode(page, copy_ext->scrlbar.mode);
-    }
-
-
-    scrlbar_refresh(page);
-
-    LV_LOG_INFO("page created");
-
-    return page;
-}
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param page pointer to an object
- */
-void lv_page_clean(lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_obj_t * scrl = lv_page_get_scrollable(page);
-    lv_obj_clean(scrl);
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @param sb_mode the new mode from 'lv_page_sb.mode_t' enum
- */
-void lv_page_set_scrollbar_mode(lv_obj_t * page, lv_scrollbar_mode_t sb_mode)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    if(ext->scrlbar.mode == sb_mode) return;
-
-    if(sb_mode == LV_SCROLLBAR_MODE_HIDE)
-        ext->scrlbar.mode |= LV_SCROLLBAR_MODE_HIDE; /*Set the hidden flag*/
-    else if(sb_mode == LV_SCROLLBAR_MODE_UNHIDE)
-        ext->scrlbar.mode &= (~LV_SCROLLBAR_MODE_HIDE); /*Clear the hidden flag*/
-    else {
-        if(ext->scrlbar.mode & LV_SCROLLBAR_MODE_HIDE) sb_mode |= LV_SCROLLBAR_MODE_HIDE;
-        ext->scrlbar.mode = sb_mode;
-    }
-
-    ext->scrlbar.hor_draw = 0;
-    ext->scrlbar.ver_draw = 0;
-
-    scrlbar_refresh(page);
-    lv_obj_invalidate(page);
-}
-
-/**
- * Set the animation time for the page
- * @param page pointer to a page object
- * @param anim_time animation time in milliseconds
- */
-void lv_page_set_anim_time(lv_obj_t * page, uint16_t anim_time)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    ext->anim_time      = anim_time;
-#else
-    (void)page;      /*Unused*/
-    (void)anim_time; /*Unused*/
-#endif
-}
-
-/**
- * Enable the scroll propagation feature. If enabled then the page will move its parent if there is
- * no more space to scroll.
- * The page needs to have a page-like parent (e.g. `lv_page`, `lv_tabview` tab, `lv_win` content area etc)
- * If enabled drag direction will be changed `LV_DRAG_DIR_ONE` automatically to allow scrolling only in one direction at one time.
- * @param page pointer to a Page
- * @param en true or false to enable/disable scroll propagation
- */
-void lv_page_set_scroll_propagation(lv_obj_t * page, bool en)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    if(en) lv_obj_set_drag_dir(ext->scrl, LV_DRAG_DIR_ONE);
-    else lv_obj_set_drag_dir(ext->scrl, LV_DRAG_DIR_BOTH);
-
-    ext->scroll_prop    = en ? 1 : 0;
-}
-
-/**
- * Enable the edge flash effect. (Show an arc when the an edge is reached)
- * @param page pointer to a Page
- * @param en true or false to enable/disable end flash
- */
-void lv_page_set_edge_flash(lv_obj_t * page, bool en)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_page_ext_t * ext     = lv_obj_get_ext_attr(page);
-    ext->edge_flash.enabled = en ? 1 : 0;
-#else
-    (void)page;
-    (void)en;
-#endif
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the scrollable object of a page
- * @param page pointer to a page object
- * @return pointer to a container which is the scrollable part of the page
- */
-lv_obj_t * lv_page_get_scrollable(const lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-
-    return ext->scrl;
-}
-
-/**
- * Get the animation time
- * @param page pointer to a page object
- * @return the animation time in milliseconds
- */
-uint16_t lv_page_get_anim_time(const lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    return ext->anim_time;
-#else
-    (void)page; /*Unused*/
-    return 0;
-#endif
-}
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @return the mode from 'lv_page_sb.mode_t' enum
- */
-lv_scrollbar_mode_t lv_page_get_scrollbar_mode(const lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    return ext->scrlbar.mode;
-}
-
-/**
- * Get the scroll propagation property
- * @param page pointer to a Page
- * @return true or false
- */
-bool lv_page_get_scroll_propagation(lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    return ext->scroll_prop ? true : false;
-}
-
-/**
- * Get the edge flash effect property.
- * @param page pointer to a Page
- * return true or false
- */
-bool lv_page_get_edge_flash(lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    return ext->edge_flash.enabled == 0 ? false : true;
-#else
-    (void)page;
-    return false;
-#endif
-}
-
-/**
- * Get that width which can be set to the children to still not cause overflow (show scrollbars)
- * @param page pointer to a page object
- * @return the width which still fits into the page
- */
-lv_coord_t lv_page_get_width_fit(lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    lv_style_int_t bg_left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
-    lv_style_int_t scrl_left = lv_obj_get_style_pad_left(ext->scrl, LV_CONT_PART_MAIN);
-    lv_style_int_t scrl_right = lv_obj_get_style_pad_right(ext->scrl, LV_CONT_PART_MAIN);
-
-    return lv_obj_get_width(page) - bg_left - bg_right - scrl_left - scrl_right;
-}
-
-/**
- * Get that height which can be set to the children to still not cause overflow (show scrollbars)
- * @param page pointer to a page object
- * @return the height which still fits into the page
- */
-lv_coord_t lv_page_get_height_fit(lv_obj_t * page)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
-    lv_style_int_t scrl_top = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
-    lv_style_int_t scrl_bottom = lv_obj_get_style_pad_bottom(ext->scrl, LV_CONT_PART_MAIN);
-
-    return lv_obj_get_height(page) - bg_top - bg_bottom - scrl_top - scrl_bottom;
-}
-
-/**
- * Divide the width of the object and get the width of a given number of columns.
- * Take into account the paddings of the background and scrollable too.
- * @param page pointer to an object
- * @param div indicates how many columns are assumed.
- * If 1 the width will be set the the parent's width
- * If 2 only half parent width - inner padding of the parent
- * If 3 only third parent width - 2 * inner padding of the parent
- * @param span how many columns are combined
- * @return the width according to the given parameters
- */
-lv_coord_t lv_page_get_width_grid(lv_obj_t * page, uint8_t div, uint8_t span)
-{
-
-    lv_coord_t obj_w = lv_page_get_width_fit(page);
-    lv_style_int_t pinner = lv_obj_get_style_pad_inner(page, LV_PAGE_PART_SCROLLABLE);
-
-    lv_coord_t r = (obj_w - (div - 1) * pinner) / div;
-
-    r = r * span + (span - 1) * pinner;
-    return r;
-}
-
-/**
- * Divide the height of the object and get the height of a given number of rows.
- * Take into account the paddings of the background and scrollable too.
- * @param obj pointer to an object
- * @param div indicates how many rows are assumed.
- * If 1 the height will be set the the parent's height
- * If 2 only half parent height - inner padding of the parent
- * If 3 only third parent height - 2 * inner padding of the parent
- * @param span how many rows are combined
- * @return the height according to the given parameters
- */
-lv_coord_t lv_page_get_height_grid(lv_obj_t * page, uint8_t div, uint8_t span)
-{
-    lv_coord_t obj_h = lv_page_get_height_fit(page);
-    lv_style_int_t pinner = lv_obj_get_style_pad_inner(page, LV_PAGE_PART_SCROLLABLE);
-
-    lv_coord_t r = (obj_h - (div - 1) * pinner) / div;
-
-    r = r * span + (span - 1) * pinner;
-    return r;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Find whether the page has been scrolled to a certain edge.
- * @param page Page object
- * @param edge Edge to check
- * @return true if the page is on the specified edge
- */
-bool lv_page_on_edge(lv_obj_t * page, lv_page_edge_t edge)
-{
-    lv_obj_t * scrl               = lv_page_get_scrollable(page);
-    lv_area_t page_coords;
-    lv_area_t scrl_coords;
-
-    lv_obj_get_coords(scrl, &scrl_coords);
-    lv_obj_get_coords(page, &page_coords);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
-    lv_style_int_t right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
-    lv_style_int_t top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
-
-    if((edge & LV_PAGE_EDGE_TOP) && scrl_coords.y1 == page_coords.y1 + top) return true;
-    if((edge & LV_PAGE_EDGE_BOTTOM) && scrl_coords.y2 == page_coords.y2 - bottom) return true;
-    if((edge & LV_PAGE_EDGE_LEFT) && scrl_coords.x1 == page_coords.x1 + left) return true;
-    if((edge & LV_PAGE_EDGE_RIGHT) && scrl_coords.x2 == page_coords.x2 - right) return true;
-
-    return false;
-}
-
-/**
- * Glue the object to the page. After it the page can be moved (dragged) with this object too.
- * @param page pointer to a page object
- * @param obj pointer to an object on a page
- * @param glue true: enable glue, false: disable glue
- */
-void lv_page_glue_obj(lv_obj_t * page, lv_obj_t * obj, bool glue)
-{
-    lv_obj_set_drag_parent(obj, glue);
-    lv_obj_set_drag(obj, glue);
-}
-
-/**
- * Focus on an object. It ensures that the object will be visible on the page.
- * @param page pointer to a page object
- * @param obj pointer to an object to focus (must be on the page)
- * @param anim_en LV_ANIM_ON to focus with animation; LV_ANIM_OFF to focus without animation
- */
-void lv_page_focus(lv_obj_t * page, const lv_obj_t * obj, lv_anim_enable_t anim_en)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-
-#if LV_USE_ANIMATION
-    /* Be sure there is no position changing animation in progress
-     * because it can override the current changes*/
-    lv_anim_del(page, (lv_anim_exec_xcb_t)lv_obj_set_x);
-    lv_anim_del(page, (lv_anim_exec_xcb_t)lv_obj_set_y);
-    lv_anim_del(ext->scrl, (lv_anim_exec_xcb_t)lv_obj_set_x);
-    lv_anim_del(ext->scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
-#endif
-
-    /*if using focus mode, change target to parent*/
-    obj = lv_obj_get_focused_obj(obj);
-
-
-    /*If obj is higher then the page focus where the "error" is smaller*/
-    lv_coord_t obj_y      = obj->coords.y1 - ext->scrl->coords.y1;
-    lv_coord_t obj_h      = lv_obj_get_height(obj);
-    lv_coord_t scrlable_y = lv_obj_get_y(ext->scrl);
-    lv_coord_t page_h     = lv_obj_get_height(page);
-
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
-    lv_style_int_t scrl_top = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
-    lv_style_int_t scrl_bottom = lv_obj_get_style_pad_bottom(ext->scrl, LV_CONT_PART_MAIN);
-
-    lv_coord_t top_err = -((scrlable_y + obj_y) - bg_top);
-    lv_coord_t bot_err = scrlable_y + obj_y + obj_h - (page_h - bg_bottom);
-
-    /*Out of the page on the top*/
-    if((obj_h <= page_h && top_err > 0) || (obj_h > page_h && top_err < bot_err)) {
-        /*Calculate a new position and let some space above*/
-        scrlable_y = -(obj_y - scrl_top - bg_top);
-        scrlable_y += scrl_top;
-    }
-    /*Out of the page on the bottom*/
-    else if((obj_h <= page_h && bot_err > 0) || (obj_h > page_h && top_err >= bot_err)) {
-        /*Calculate a new position and let some space below*/
-        scrlable_y = -(obj_y + scrl_bottom + bg_bottom);
-        scrlable_y -= scrl_bottom;
-        scrlable_y += page_h - obj_h;
-    }
-
-
-    /*If obj is wider then the page focus where the "error" is smaller*/
-    lv_coord_t obj_x      = obj->coords.x1 - ext->scrl->coords.x1;
-    lv_coord_t obj_w      = lv_obj_get_width(obj);
-    lv_coord_t scrlable_x = lv_obj_get_x(ext->scrl);
-    lv_coord_t page_w     = lv_obj_get_width(page);
-
-    lv_style_int_t bg_left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
-    lv_style_int_t scrl_left = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
-    lv_style_int_t scrl_right = lv_obj_get_style_pad_bottom(ext->scrl, LV_CONT_PART_MAIN);
-
-    lv_coord_t left_err  = -((scrlable_x + obj_x) - bg_left);
-    lv_coord_t right_err = scrlable_x + obj_x + obj_w - (page_w - bg_right);
-
-    /*Out of the page on the left*/
-    if((obj_w <= page_w && left_err > 0) || (obj_w > page_w && left_err < right_err)) {
-        /*Calculate a new position and let some space on the side*/
-        scrlable_x = -(obj_x - scrl_left - bg_left);
-        scrlable_x += scrl_left;
-    }
-    /*Out of the page on the rigth*/
-    else if((obj_w <= page_w && right_err > 0) || (obj_w > page_w && left_err >= right_err)) {
-        /*Calculate a new position and let some space on the side*/
-        scrlable_x = -(obj_x + scrl_right + bg_right);
-        scrlable_x -= scrl_right;
-        scrlable_x += page_w - obj_w;
-    }
-
-    if(anim_en == LV_ANIM_OFF || lv_page_get_anim_time(page) == 0) {
-        lv_obj_set_y(ext->scrl, scrlable_y);
-        lv_obj_set_x(ext->scrl, scrlable_x);
-    }
-    else {
-#if LV_USE_ANIMATION
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, ext->scrl);
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-        lv_anim_set_values(&a, lv_obj_get_y(ext->scrl), scrlable_y);
-        lv_anim_set_time(&a, lv_page_get_anim_time(page));
-        lv_anim_start(&a);
-
-        lv_anim_set_values(&a, lv_obj_get_x(ext->scrl), scrlable_x);
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_x);
-        lv_anim_start(&a);
-#endif
-    }
-}
-
-/**
- * Scroll the page horizontally
- * @param page pointer to a page object
- * @param dist the distance to scroll (< 0: scroll right; > 0 scroll left)
- */
-void lv_page_scroll_hor(lv_obj_t * page, lv_coord_t dist)
-{
-    lv_obj_t * scrl = lv_page_get_scrollable(page);
-
-#if LV_USE_ANIMATION
-    lv_anim_t a;
-    lv_anim_init(&a);
-    lv_anim_set_var(&a, scrl);
-    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_x);
-    lv_anim_set_values(&a, lv_obj_get_x(scrl), lv_obj_get_x(scrl) + dist);
-    lv_anim_set_time(&a, lv_page_get_anim_time(page));
-    lv_anim_start(&a);
-#else
-    lv_obj_set_x(scrl, lv_obj_get_x(scrl) + dist);
-#endif
-}
-
-/**
- * Scroll the page vertically
- * @param page pointer to a page object
- * @param dist the distance to scroll (< 0: scroll down; > 0 scroll up)
- */
-void lv_page_scroll_ver(lv_obj_t * page, lv_coord_t dist)
-{
-    lv_obj_t * scrl = lv_page_get_scrollable(page);
-
-#if LV_USE_ANIMATION
-    lv_anim_t a;
-    lv_anim_init(&a);
-    lv_anim_set_var(&a, scrl);
-    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-    lv_anim_set_values(&a, lv_obj_get_y(scrl), lv_obj_get_y(scrl) + dist);
-    lv_anim_set_time(&a, lv_page_get_anim_time(page));
-    lv_anim_start(&a);
-#else
-    lv_obj_set_y(scrl, lv_obj_get_y(scrl) + dist);
-#endif
-}
-
-/**
- * Not intended to use directly by the user but by other object types internally.
- * Start an edge flash animation.
- * @param page
- * @param edge the edge to flash. Can be `LV_PAGE_EDGE_LEFT/RIGHT/TOP/BOTTOM`
- */
-void lv_page_start_edge_flash(lv_obj_t * page, lv_page_edge_t edge)
-{
-#if LV_USE_ANIMATION
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    if(ext->edge_flash.enabled == 0) return;
-
-    if(ext->edge_flash.left_ip ||
-       ext->edge_flash.right_ip ||
-       ext->edge_flash.top_ip ||
-       ext->edge_flash.bottom_ip) {
-        return;
-    }
-
-    lv_anim_t a;
-    lv_anim_init(&a);
-    lv_anim_set_var(&a, page);
-    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)edge_flash_anim);
-    lv_anim_set_values(&a, 0, LV_PAGE_END_FLASH_SIZE);
-    lv_anim_set_time(&a, lv_page_get_anim_time(page));
-    lv_anim_set_playback_time(&a, lv_page_get_anim_time(page));
-    lv_anim_set_playback_delay(&a, LV_PAGE_END_ANIM_WAIT_TIME);
-    lv_anim_set_ready_cb(&a, edge_flash_anim_end);
-    lv_anim_start(&a);
-
-    switch(edge) {
-        case LV_PAGE_EDGE_BOTTOM:
-            ext->edge_flash.bottom_ip = 1;
-            break;
-        case LV_PAGE_EDGE_TOP:
-            ext->edge_flash.top_ip = 1;
-            break;
-        case LV_PAGE_EDGE_LEFT:
-            ext->edge_flash.left_ip = 1;
-            break;
-        case LV_PAGE_EDGE_RIGHT:
-            ext->edge_flash.right_ip = 1;
-            break;
-    }
-
-#else
-    LV_UNUSED(page);
-    LV_UNUSED(edge);
-#endif
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the pages
- * @param page pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_page_design(lv_obj_t * page, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_design(page, clip_area, mode);
-    }
-
-    if(mode == LV_DESIGN_DRAW_MAIN) {
-        return ancestor_design(page, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design(page, clip_area, mode);
-        lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-
-        lv_area_t sb_hor_area;
-        lv_area_t sb_ver_area;
-        /*Convert the relative coordinates to absolute*/
-        lv_area_copy(&sb_hor_area, &ext->scrlbar.hor_area);
-        sb_hor_area.x1 += page->coords.x1;
-        sb_hor_area.y1 += page->coords.y1;
-        sb_hor_area.x2 += page->coords.x1;
-        sb_hor_area.y2 += page->coords.y1;
-
-        /*Convert the relative coordinates to absolute*/
-        lv_area_copy(&sb_ver_area, &ext->scrlbar.ver_area);
-        sb_ver_area.x1 += page->coords.x1;
-        sb_ver_area.y1 += page->coords.y1;
-        sb_ver_area.x2 += page->coords.x1;
-        sb_ver_area.y2 += page->coords.y1;
-
-        if((ext->scrlbar.hor_draw && _lv_area_is_on(&sb_hor_area, clip_area)) ||
-           (ext->scrlbar.ver_draw && _lv_area_is_on(&sb_ver_area, clip_area))) {
-            /*Draw the scrollbars*/
-            lv_draw_rect_dsc_t rect_dsc;
-            lv_draw_rect_dsc_init(&rect_dsc);
-            lv_obj_init_draw_rect_dsc(page, LV_PAGE_PART_SCROLLBAR, &rect_dsc);
-            if(ext->scrlbar.hor_draw && (ext->scrlbar.mode & LV_SCROLLBAR_MODE_HIDE) == 0) {
-                lv_draw_rect(&sb_hor_area, clip_area, &rect_dsc);
-            }
-
-            if(ext->scrlbar.ver_draw && (ext->scrlbar.mode & LV_SCROLLBAR_MODE_HIDE) == 0) {
-                lv_draw_rect(&sb_ver_area, clip_area, &rect_dsc);
-            }
-        }
-
-#if LV_USE_ANIMATION
-        {
-
-
-            if(ext->edge_flash.left_ip || ext->edge_flash.right_ip || ext->edge_flash.top_ip ||
-               ext->edge_flash.bottom_ip) {
-                lv_area_t flash_area;
-                get_edge_flash_area(page, &flash_area, ext->edge_flash.state);
-
-                lv_draw_rect_dsc_t edge_draw_dsc;
-                lv_draw_rect_dsc_init(&edge_draw_dsc);
-                lv_obj_init_draw_rect_dsc(page, LV_PAGE_PART_EDGE_FLASH, &edge_draw_dsc);
-                edge_draw_dsc.radius  = LV_RADIUS_CIRCLE;
-                uint32_t opa            = (edge_draw_dsc.bg_opa * ext->edge_flash.state) / LV_PAGE_END_FLASH_SIZE;
-                edge_draw_dsc.bg_opa    = opa;
-                lv_draw_rect(&flash_area, clip_area, &edge_draw_dsc);
-            }
-        }
-#endif
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
-/**
- * Signal function of the page
- * @param page pointer to a page object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_page_get_style(page, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(page, sign, param);
-    }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        lv_get_state_info_t * info = param;
-        if(info->part == LV_PAGE_PART_SCROLLABLE) info->result = lv_obj_get_state(lv_page_get_scrollable(page),
-                                                                                      LV_CONT_PART_MAIN);
-        else info->result = lv_obj_get_state(page, info->part);
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(page, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Check whether the object being deleted is propagating scroll to the parent */
-        if(ext->scroll_prop) {
-            lv_obj_t * parent_page = lv_obj_get_parent(lv_obj_get_parent(page));
-            lv_page_ext_t * parent_ext = lv_obj_get_ext_attr(parent_page);
-            if(parent_ext->scroll_prop_obj == page) {
-                parent_ext->scroll_prop_obj = NULL;
-            }
-        }
-
-        lv_obj_clean_style_list(page, LV_PAGE_PART_SCROLLBAR);
-#if LV_USE_ANIMATION
-        lv_obj_clean_style_list(page, LV_PAGE_PART_EDGE_FLASH);
-#endif
-    }
-    /*Automatically move children to the scrollable object*/
-    else if(sign == LV_SIGNAL_CHILD_CHG) {
-        lv_obj_t * child;
-        if(ext->scrl == NULL) return LV_RES_OK;
-
-        lv_fit_t fit_left        = lv_page_get_scrl_fit_left(page);
-        lv_fit_t fit_right        = lv_page_get_scrl_fit_right(page);
-        lv_fit_t fit_top         = lv_page_get_scrl_fit_top(page);
-        lv_bidi_dir_t base_dir = lv_obj_get_base_dir(page);
-
-        lv_style_int_t scrl_left = lv_obj_get_style_pad_left(ext->scrl, LV_CONT_PART_MAIN);
-        lv_style_int_t scrl_right = lv_obj_get_style_pad_right(ext->scrl, LV_CONT_PART_MAIN);
-        lv_style_int_t scrl_top = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
-
-        child = lv_obj_get_child(page, NULL);
-        while(child != NULL) {
-            if(lv_obj_is_protected(child, LV_PROTECT_PARENT) == false) {
-                lv_obj_t * tmp = child;
-                child          = lv_obj_get_child(page, child); /*Get the next child before move this*/
-
-                /* Reposition the child to take padding into account
-                 * It's required to keep new the object on the same coordinate if FIT is enabled.*/
-                if((tmp->coords.x1 == page->coords.x1)  &&
-                   (fit_left == LV_FIT_TIGHT || fit_left == LV_FIT_MAX) &&
-                   base_dir != LV_BIDI_DIR_RTL) {
-                    tmp->coords.x1 += scrl_left;
-                    tmp->coords.x2 += scrl_left;
-                }
-                else if((tmp->coords.x2 == page->coords.x2) &&
-                        (fit_right == LV_FIT_TIGHT || fit_right == LV_FIT_MAX)
-                        && base_dir == LV_BIDI_DIR_RTL) {
-                    tmp->coords.x1 -= scrl_right;
-                    tmp->coords.x2 -= scrl_right;
-                }
-                if((tmp->coords.y1 == page->coords.y1) && (fit_top == LV_FIT_TIGHT || fit_top == LV_FIT_MAX)) {
-                    tmp->coords.y1 += scrl_top;
-                    tmp->coords.y2 += scrl_top;
-                }
-                lv_obj_set_parent(tmp, ext->scrl);
-            }
-            else {
-                child = lv_obj_get_child(page, child);
-            }
-        }
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        lv_style_int_t sb_width = lv_obj_get_style_size(page, LV_PAGE_PART_SCROLLBAR);
-        lv_area_set_height(&ext->scrlbar.hor_area, sb_width);
-        lv_area_set_width(&ext->scrlbar.ver_area, sb_width);
-
-        /*The scrollbars are important only if they are visible now*/
-        if(ext->scrlbar.hor_draw || ext->scrlbar.ver_draw) scrlbar_refresh(page);
-
-        /*Refresh the ext. size because the scrollbars might be positioned out of the page*/
-        refr_ext_draw_pad(page);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        /*Refresh the scrollbar and notify the scrl if the size is changed*/
-        if(ext->scrl != NULL && (lv_obj_get_width(page) != lv_area_get_width(param) ||
-                                 lv_obj_get_height(page) != lv_area_get_height(param))) {
-            ext->scrl->signal_cb(ext->scrl, LV_SIGNAL_COORD_CHG, &ext->scrl->coords);
-
-            /*The scrollbars are important only if they are visible now*/
-            if(ext->scrlbar.hor_draw || ext->scrlbar.ver_draw) scrlbar_refresh(page);
-        }
-    }
-    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        refr_ext_draw_pad(page);
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        uint32_t c = *((uint32_t *)param);
-
-        if(c == LV_KEY_DOWN) {
-            lv_page_scroll_ver(page, -lv_obj_get_height(page) / 4);
-        }
-        else if(c == LV_KEY_UP) {
-            lv_page_scroll_ver(page, lv_obj_get_height(page) / 4);
-        }
-        else if(c == LV_KEY_RIGHT) {
-            /*If the page can't be scrolled horizontally because it's not wide enough then scroll it
-             * vertically*/
-            if(lv_page_get_scrl_width(page) <= lv_obj_get_width(page))
-                lv_page_scroll_ver(page, -lv_obj_get_height(page) / 4);
-            else
-                lv_page_scroll_hor(page, -lv_obj_get_width(page) / 4);
-        }
-        else if(c == LV_KEY_LEFT) {
-            /*If the page can't be scrolled horizontally because it's not wide enough then scroll it
-             * vertically*/
-            if(lv_page_get_scrl_width(page) <= lv_obj_get_width(page))
-                lv_page_scroll_ver(page, lv_obj_get_height(page) / 4);
-            else
-                lv_page_scroll_hor(page, lv_obj_get_width(page) / 4);
-        }
-#endif
-    }
-    else if(sign == LV_SIGNAL_GET_EDITABLE) {
-#if LV_USE_GROUP
-        bool * editable = (bool *)param;
-        *editable       = true;
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Signal function of the scrollable part of a page
- * @param scrl pointer to the scrollable object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
-{
-
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        return ancestor_signal(scrl, sign, param);
-    }
-
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(scrl, sign, param);
-
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    lv_obj_t * page               = lv_obj_get_parent(scrl);
-    lv_page_ext_t * page_ext      = lv_obj_get_ext_attr(page);
-
-    if(sign == LV_SIGNAL_COORD_CHG) {
-        lv_obj_t * page_parent = lv_obj_get_parent(page);
-
-        /*Handle scroll propagation*/
-        lv_indev_t * indev = lv_indev_get_act();
-        if(page_ext->scroll_prop  && indev) {
-            lv_point_t * drag_sum = &indev->proc.types.pointer.drag_sum;
-            lv_page_ext_t * parent_ext = lv_obj_get_ext_attr(lv_obj_get_parent(page_parent));
-            if(parent_ext->scroll_prop_obj == NULL) {
-                /*If the dragging just started or scroll is already propagated to this object
-                 *  enable the scroll propagation if the conditions are met*/
-                if((lv_indev_is_scrolling(indev) == false || page_ext->scroll_prop_obj) && (drag_sum->y || drag_sum->x)) {
-                    /*Propagate vertically?*/
-                    if((drag_sum->y > 0 && lv_page_on_edge(page, LV_PAGE_EDGE_TOP)) ||
-                       (drag_sum->y < 0 && lv_page_on_edge(page, LV_PAGE_EDGE_BOTTOM))) {
-                        lv_obj_set_drag_parent(page, true);
-                        lv_obj_set_drag_parent(scrl, true);
-                        parent_ext->scroll_prop_obj = page;
-                    }
-                    /*Propagate horizontally?*/
-                    if((drag_sum->x > 0 && lv_page_on_edge(page, LV_PAGE_EDGE_LEFT)) ||
-                       (drag_sum->x < 0 && lv_page_on_edge(page, LV_PAGE_EDGE_RIGHT))) {
-                        lv_obj_set_drag_parent(page, true);
-                        lv_obj_set_drag_parent(scrl, true);
-                        parent_ext->scroll_prop_obj = page;
-                    }
-                }
-            }
-        }
-
-        scrl_reposition(page);
-
-        lv_page_ext_t * ext      = lv_obj_get_ext_attr(page);
-
-        /*The scrollbars are important only if they are visible now or the scrollable's size has changed*/
-        if((ext->scrlbar.hor_draw || ext->scrlbar.ver_draw) ||
-           (lv_obj_get_width(scrl) != lv_area_get_width(param) || lv_obj_get_height(scrl) != lv_area_get_height(param))) {
-            scrlbar_refresh(page);
-        }
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        scrl_reposition(page);
-        scrlbar_refresh(page);
-    }
-    else if(sign == LV_SIGNAL_DRAG_BEGIN) {
-        if(page_ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) {
-            scrlbar_refresh(page);
-        }
-    }
-    else if(sign == LV_SIGNAL_DRAG_END) {
-        /*Scroll propagation is finished on drag end*/
-        if(page_ext->scroll_prop_obj) {
-            lv_obj_t * scroller_page = page_ext->scroll_prop_obj;
-            lv_page_ext_t * scroller_page_ext      = lv_obj_get_ext_attr(scroller_page);
-            page_ext->scroll_prop_obj = NULL;
-            lv_obj_set_drag_parent(scroller_page, false);
-            lv_obj_set_drag_parent(lv_page_get_scrollable(scroller_page), false);
-
-            /*Hide scrollbars if required*/
-            if(scroller_page_ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) {
-                lv_area_t sb_area_tmp;
-                if(scroller_page_ext->scrlbar.hor_draw) {
-                    lv_area_copy(&sb_area_tmp, &scroller_page_ext->scrlbar.hor_area);
-                    sb_area_tmp.x1 += scroller_page->coords.x1;
-                    sb_area_tmp.y1 += scroller_page->coords.y1;
-                    sb_area_tmp.x2 += scroller_page->coords.x1;
-                    sb_area_tmp.y2 += scroller_page->coords.y1;
-                    lv_obj_invalidate_area(scroller_page, &sb_area_tmp);
-                    scroller_page_ext->scrlbar.hor_draw = 0;
-                }
-                if(scroller_page_ext->scrlbar.ver_draw) {
-                    lv_area_copy(&sb_area_tmp, &scroller_page_ext->scrlbar.ver_area);
-                    sb_area_tmp.x1 += scroller_page->coords.x1;
-                    sb_area_tmp.y1 += scroller_page->coords.y1;
-                    sb_area_tmp.x2 += scroller_page->coords.x1;
-                    sb_area_tmp.y2 += scroller_page->coords.y1;
-                    lv_obj_invalidate_area(scroller_page, &sb_area_tmp);
-                    scroller_page_ext->scrlbar.ver_draw = 0;
-                }
-            }
-
-            /*The scrolling can be chained so stop all of them*/
-            lv_page_ext_t * scroller_ext = lv_obj_get_ext_attr(scroller_page);
-            while(scroller_ext->scroll_prop_obj) {
-                scroller_page = scroller_ext->scroll_prop_obj;
-                scroller_ext->scroll_prop_obj = NULL;
-                lv_obj_set_drag_parent(scroller_page, false);
-                lv_obj_set_drag_parent(lv_page_get_scrollable(scroller_page), false);
-
-                /*Hide scrollbars if required*/
-                if(scroller_page_ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) {
-                    scroller_page_ext->scrlbar.hor_draw = 0;
-                    scroller_page_ext->scrlbar.ver_draw = 0;
-                    lv_obj_invalidate(scroller_page);
-                }
-                scroller_ext = lv_obj_get_ext_attr(scroller_page);
-            }
-        }
-
-        /*Hide scrollbars if required*/
-        if(page_ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) {
-            lv_area_t sb_area_tmp;
-            if(page_ext->scrlbar.hor_draw) {
-                lv_area_copy(&sb_area_tmp, &page_ext->scrlbar.hor_area);
-                sb_area_tmp.x1 += page->coords.x1;
-                sb_area_tmp.y1 += page->coords.y1;
-                sb_area_tmp.x2 += page->coords.x1;
-                sb_area_tmp.y2 += page->coords.y1;
-                lv_obj_invalidate_area(page, &sb_area_tmp);
-                page_ext->scrlbar.hor_draw = 0;
-            }
-            if(page_ext->scrlbar.ver_draw) {
-                lv_area_copy(&sb_area_tmp, &page_ext->scrlbar.ver_area);
-                sb_area_tmp.x1 += page->coords.x1;
-                sb_area_tmp.y1 += page->coords.y1;
-                sb_area_tmp.x2 += page->coords.x1;
-                sb_area_tmp.y2 += page->coords.y1;
-                lv_obj_invalidate_area(page, &sb_area_tmp);
-                page_ext->scrlbar.ver_draw = 0;
-            }
-        }
-    }
-    else if(sign == LV_SIGNAL_CLEANUP) {
-        page_ext->scrl = NULL;
-
-    }
-    return res;
-}
-
-/**
- * Propagate the input device related event of the scrollable to the parent page background
- * It is used by default if the scrollable's event is not specified
- * @param scrl pointer to the page's scrollable object
- * @param event type of the event
- * @param data data of the event
- */
-static void scrl_def_event_cb(lv_obj_t * scrl, lv_event_t event)
-{
-    lv_obj_t * page = lv_obj_get_parent(scrl);
-
-    /*clang-format off*/
-    if(event == LV_EVENT_PRESSED || event == LV_EVENT_PRESSING || event == LV_EVENT_PRESS_LOST ||
-       event == LV_EVENT_RELEASED || event == LV_EVENT_SHORT_CLICKED || event == LV_EVENT_CLICKED ||
-       event == LV_EVENT_LONG_PRESSED || event == LV_EVENT_LONG_PRESSED_REPEAT ||
-       event == LV_EVENT_DRAG_BEGIN || event == LV_EVENT_DRAG_END || event == LV_EVENT_DRAG_THROW_BEGIN) {
-        lv_event_send(page, event, lv_event_get_data());
-    }
-    /*clang-format on*/
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param page pointer the object
- * @param part the part of the page. (LV_PAGE_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_page_get_style(lv_obj_t * page, uint8_t part)
-{
-    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
-
-    lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_PAGE_PART_BG:
-            style_dsc_p = &page->style_list;
-            break;
-        case LV_PAGE_PART_SCROLLABLE:
-            style_dsc_p = lv_obj_get_style_list(ext->scrl, LV_CONT_PART_MAIN);
-            break;
-        case LV_PAGE_PART_SCROLLBAR:
-            style_dsc_p = &ext->scrlbar.style;
-            break;
-#if LV_USE_ANIMATION
-        case LV_PAGE_PART_EDGE_FLASH:
-            style_dsc_p = &ext->edge_flash.style;
-            break;
-#endif
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-static void scrl_reposition(lv_obj_t * page)
-{
-    /*Limit the position of the scrollable object to be always visible
-     * (Do not let its edge inner then its parent respective edge)*/
-    lv_obj_t * scrl = lv_page_get_scrollable(page);
-    lv_coord_t new_x = lv_obj_get_x(scrl);
-    lv_coord_t new_y = lv_obj_get_y(scrl);
-    bool refr_x      = false;
-    bool refr_y      = false;
-    lv_area_t page_coords;
-    lv_area_t scrl_coords;
-    lv_obj_get_coords(scrl, &scrl_coords);
-    lv_obj_get_coords(page, &page_coords);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
-    lv_style_int_t right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
-    lv_style_int_t top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
-
-    /*scrollable width smaller then page width? -> align to left*/
-    if(lv_area_get_width(&scrl_coords) + left + right <= lv_area_get_width(&page_coords)) {
-        if(scrl_coords.x1 != page_coords.x1 + left) {
-            new_x  = left;
-            refr_x = true;
-        }
-    }
-    else {
-        /*The edges of the scrollable can not be in the page (minus hpad) */
-        if(scrl_coords.x2 < page_coords.x2 - right) {
-            new_x = lv_area_get_width(&page_coords) - lv_area_get_width(&scrl_coords) - right; /* Right align */
-            refr_x = true;
-            lv_page_start_edge_flash(page, LV_PAGE_EDGE_RIGHT);
-        }
-        else if(scrl_coords.x1 > page_coords.x1 + left) {
-            new_x  = left; /*Left align*/
-            refr_x = true;
-            lv_page_start_edge_flash(page, LV_PAGE_EDGE_LEFT);
-        }
-    }
-
-    /*scrollable height smaller then page height? -> align to top*/
-    if(lv_area_get_height(&scrl_coords) + top + bottom <= lv_area_get_height(&page_coords)) {
-        if(scrl_coords.y1 != page_coords.y1 + top) {
-            new_y  = top;
-            refr_y = true;
-        }
-    }
-    else {
-        /*The edges of the scrollable can not be in the page (minus vpad) */
-        if(scrl_coords.y2 < page_coords.y2 - bottom) {
-            new_y = lv_area_get_height(&page_coords) - lv_area_get_height(&scrl_coords) - bottom; /* Bottom align */
-            refr_y = true;
-            lv_page_start_edge_flash(page, LV_PAGE_EDGE_BOTTOM);
-        }
-        else if(scrl_coords.y1 > page_coords.y1 + top) {
-            new_y  = top; /*Top align*/
-            refr_y = true;
-            lv_page_start_edge_flash(page, LV_PAGE_EDGE_TOP);
-        }
-    }
-
-    if(refr_x || refr_y) {
-        lv_obj_set_pos(scrl, new_x, new_y);
-    }
-}
-
-/**
- * Refresh the position and size of the scroll bars.
- * @param page pointer to a page object
- */
-static void scrlbar_refresh(lv_obj_t * page)
-{
-    lv_page_ext_t * ext      = lv_obj_get_ext_attr(page);
-    lv_obj_t * scrl          = ext->scrl;
-    lv_coord_t size_tmp;
-    lv_coord_t scrl_w = lv_obj_get_width(scrl);
-    lv_coord_t scrl_h = lv_obj_get_height(scrl);
-    lv_coord_t obj_w  = lv_obj_get_width(page);
-    lv_coord_t obj_h  = lv_obj_get_height(page);
-
-    lv_style_int_t sb_width = lv_obj_get_style_size(page, LV_PAGE_PART_SCROLLBAR);
-    lv_style_int_t sb_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_SCROLLBAR);
-    lv_style_int_t sb_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_SCROLLBAR);
-
-    lv_style_int_t bg_left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
-
-    /*Always let 'scrollbar width' padding above, under, left and right to the scrollbars
-     * else:
-     * - horizontal and vertical scrollbars can overlap on the corners
-     * - if the page has radius the scrollbar can be out of the radius  */
-    lv_coord_t sb_hor_pad = LV_MATH_MAX(sb_width, sb_right);
-    lv_coord_t sb_ver_pad = LV_MATH_MAX(sb_width, sb_bottom);
-
-    if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_OFF) return;
-
-    if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_ON) {
-        ext->scrlbar.hor_draw = 1;
-        ext->scrlbar.ver_draw = 1;
-    }
-
-    /*Invalidate the current (old) scrollbar areas*/
-    lv_area_t sb_area_tmp;
-    if(ext->scrlbar.hor_draw != 0) {
-        lv_area_copy(&sb_area_tmp, &ext->scrlbar.hor_area);
-        sb_area_tmp.x1 += page->coords.x1;
-        sb_area_tmp.y1 += page->coords.y1;
-        sb_area_tmp.x2 += page->coords.x1;
-        sb_area_tmp.y2 += page->coords.y1;
-        lv_obj_invalidate_area(page, &sb_area_tmp);
-    }
-    if(ext->scrlbar.ver_draw != 0) {
-        lv_area_copy(&sb_area_tmp, &ext->scrlbar.ver_area);
-        sb_area_tmp.x1 += page->coords.x1;
-        sb_area_tmp.y1 += page->coords.y1;
-        sb_area_tmp.x2 += page->coords.x1;
-        sb_area_tmp.y2 += page->coords.y1;
-        lv_obj_invalidate_area(page, &sb_area_tmp);
-    }
-
-    /*Full sized horizontal scrollbar*/
-    if(scrl_w <= obj_w - bg_left - bg_right) {
-        lv_area_set_width(&ext->scrlbar.hor_area, obj_w - 2 * sb_hor_pad);
-        _lv_area_set_pos(&ext->scrlbar.hor_area, sb_hor_pad,
-                         obj_h - sb_width - sb_bottom);
-        if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_AUTO ||
-           ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) ext->scrlbar.hor_draw = 0;
-    }
-    /*Smaller horizontal scrollbar*/
-    else {
-        size_tmp =
-            (obj_w * (obj_w - (2 * sb_hor_pad))) / (scrl_w + bg_left + bg_right);
-        if(size_tmp < LV_PAGE_SB_MIN_SIZE) size_tmp = LV_PAGE_SB_MIN_SIZE;
-        lv_area_set_width(&ext->scrlbar.hor_area, size_tmp);
-
-        _lv_area_set_pos(&ext->scrlbar.hor_area,
-                         sb_hor_pad +
-                         (-(lv_obj_get_x(scrl) - bg_left) * (obj_w - size_tmp - 2 * sb_hor_pad)) /
-                         (scrl_w + bg_left + bg_right - obj_w),
-                         obj_h - sb_width - sb_bottom);
-
-        if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_AUTO ||
-           ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) ext->scrlbar.hor_draw = 1;
-    }
-
-    /*Full sized vertical scroll bar*/
-    if(scrl_h <= obj_h - bg_top - bg_bottom) {
-        lv_area_set_height(&ext->scrlbar.ver_area, obj_h - 2 * sb_ver_pad);
-        _lv_area_set_pos(&ext->scrlbar.ver_area,
-                         obj_w - sb_width - sb_right, sb_ver_pad);
-        if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_AUTO ||
-           ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) ext->scrlbar.ver_draw = 0;
-    }
-    /*Smaller vertical scroll bar*/
-    else {
-        size_tmp =
-            (obj_h * (obj_h - (2 * sb_ver_pad))) / (scrl_h + bg_top + bg_bottom);
-        if(size_tmp < LV_PAGE_SB_MIN_SIZE) size_tmp = LV_PAGE_SB_MIN_SIZE;
-        lv_area_set_height(&ext->scrlbar.ver_area, size_tmp);
-
-        _lv_area_set_pos(&ext->scrlbar.ver_area,
-                         obj_w - sb_width - sb_right,
-                         sb_ver_pad + (-(lv_obj_get_y(scrl) - bg_left) *
-                                       (obj_h - size_tmp - 2 * sb_ver_pad)) /
-                         (scrl_h + bg_top + bg_bottom - obj_h));
-
-        if(ext->scrlbar.mode == LV_SCROLLBAR_MODE_AUTO ||
-           ext->scrlbar.mode == LV_SCROLLBAR_MODE_DRAG) ext->scrlbar.ver_draw = 1;
-    }
-
-    /*Invalidate the new scrollbar areas*/
-    if(ext->scrlbar.hor_draw != 0) {
-        lv_area_copy(&sb_area_tmp, &ext->scrlbar.hor_area);
-        sb_area_tmp.x1 += page->coords.x1;
-        sb_area_tmp.y1 += page->coords.y1;
-        sb_area_tmp.x2 += page->coords.x1;
-        sb_area_tmp.y2 += page->coords.y1;
-        lv_obj_invalidate_area(page, &sb_area_tmp);
-    }
-    if(ext->scrlbar.ver_draw != 0) {
-        lv_area_copy(&sb_area_tmp, &ext->scrlbar.ver_area);
-        sb_area_tmp.x1 += page->coords.x1;
-        sb_area_tmp.y1 += page->coords.y1;
-        sb_area_tmp.x2 += page->coords.x1;
-        sb_area_tmp.y2 += page->coords.y1;
-        lv_obj_invalidate_area(page, &sb_area_tmp);
-    }
-}
-
-static void refr_ext_draw_pad(lv_obj_t * page)
-{
-    lv_style_int_t sb_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_SCROLLBAR);
-    lv_style_int_t sb_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_SCROLLBAR);
-
-    /*Ensure ext. size for the scrollbars if they are out of the page*/
-    if(page->ext_draw_pad < (-sb_right)) page->ext_draw_pad = -sb_right;
-    if(page->ext_draw_pad < (-sb_bottom)) page->ext_draw_pad = -sb_bottom;
-}
-
-#if LV_USE_ANIMATION
-static void edge_flash_anim(void * page, lv_anim_value_t v)
-{
-    lv_page_ext_t * ext   = lv_obj_get_ext_attr(page);
-    ext->edge_flash.state = v;
-
-    lv_area_t flash_area;
-    get_edge_flash_area(page, &flash_area, LV_PAGE_END_FLASH_SIZE);
-    lv_obj_invalidate_area(page, &flash_area);
-}
-
-static void edge_flash_anim_end(lv_anim_t * a)
-{
-    lv_area_t flash_area;
-    get_edge_flash_area(a->var, &flash_area, LV_PAGE_END_FLASH_SIZE);
-    lv_obj_invalidate_area(a->var, &flash_area);
-
-    lv_page_ext_t * ext       = lv_obj_get_ext_attr(a->var);
-    ext->edge_flash.top_ip    = 0;
-    ext->edge_flash.bottom_ip = 0;
-    ext->edge_flash.left_ip   = 0;
-    ext->edge_flash.right_ip  = 0;
-
-}
-
-static void get_edge_flash_area(lv_obj_t * page, lv_area_t * flash_area, lv_coord_t state)
-{
-    lv_coord_t page_w = lv_obj_get_width(page);
-    lv_coord_t page_h = lv_obj_get_height(page);
-    lv_page_ext_t * ext   = lv_obj_get_ext_attr(page);
-
-    if(ext->edge_flash.top_ip) {
-        flash_area->x1 = page->coords.x1 - page_w;
-        flash_area->x2 = page->coords.x2 + page_w;
-        flash_area->y1 = page->coords.y1 - 3 * page_w + state;
-        flash_area->y2 = page->coords.y1 + state;
-    }
-    else if(ext->edge_flash.bottom_ip) {
-        flash_area->x1 = page->coords.x1 - page_w;
-        flash_area->x2 = page->coords.x2 + page_w;
-        flash_area->y1 = page->coords.y2 - state;
-        flash_area->y2 = page->coords.y2 + 3 * page_w - state;
-    }
-    else if(ext->edge_flash.right_ip) {
-        flash_area->x1 = page->coords.x2 - state;
-        flash_area->x2 = page->coords.x2 + 3 * page_h - state;
-        flash_area->y1 = page->coords.y1 - page_h;
-        flash_area->y2 = page->coords.y2 + page_h;
-    }
-    else if(ext->edge_flash.left_ip) {
-        flash_area->x1 = page->coords.x1 - 3 * page_h + state;
-        flash_area->x2 = page->coords.x1 + state;
-        flash_area->y1 = page->coords.y1 - page_h;
-        flash_area->y2 = page->coords.y2 + page_h;
-    }
-    else {
-        lv_area_set(flash_area, 0, 0, -1, -1);
-    }
-}
-
-#endif
-
-#endif
diff --git a/src/lv_widgets/lv_page.h b/src/lv_widgets/lv_page.h
deleted file mode 100644
index 387afc6e7..000000000
--- a/src/lv_widgets/lv_page.h
+++ /dev/null
@@ -1,427 +0,0 @@
-/**
- * @file lv_page.h
- *
- */
-
-#ifndef LV_PAGE_H
-#define LV_PAGE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_PAGE != 0
-
-/*Testing of dependencies*/
-#if LV_USE_CONT == 0
-#error "lv_page: lv_cont is required. Enable it in lv_conf.h (LV_USE_CONT  1) "
-#endif
-
-#include "lv_cont.h"
-#include "../lv_core/lv_indev.h"
-#include "../lv_misc/lv_anim.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/** Scrollbar modes: shows when should the scrollbars be visible*/
-enum {
-    LV_SCROLLBAR_MODE_OFF    = 0x0, /**< Never show scroll bars*/
-    LV_SCROLLBAR_MODE_ON     = 0x1, /**< Always show scroll bars*/
-    LV_SCROLLBAR_MODE_DRAG   = 0x2, /**< Show scroll bars when page is being dragged*/
-    LV_SCROLLBAR_MODE_AUTO   = 0x3, /**< Show scroll bars when the scrollable container is large enough to be scrolled*/
-    LV_SCROLLBAR_MODE_HIDE   = 0x4, /**< Hide the scroll bar temporally*/
-    LV_SCROLLBAR_MODE_UNHIDE = 0x8, /**< Unhide the previously hidden scroll bar. Recover original mode too*/
-};
-typedef uint8_t lv_scrollbar_mode_t;
-
-/** Edges: describes the four edges of the page*/
-enum { LV_PAGE_EDGE_LEFT = 0x1, LV_PAGE_EDGE_TOP = 0x2, LV_PAGE_EDGE_RIGHT = 0x4, LV_PAGE_EDGE_BOTTOM = 0x8 };
-typedef uint8_t lv_page_edge_t;
-
-/*Data of page*/
-typedef struct {
-    lv_cont_ext_t bg; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * scrl; /*The scrollable object on the background*/
-    struct {
-        lv_style_list_t style; /*Style of scrollbars*/
-        lv_area_t hor_area;       /*Horizontal scrollbar area relative to the page. (Handled by the library) */
-        lv_area_t ver_area;       /*Vertical scrollbar area relative to the page (Handled by the library)*/
-        uint8_t hor_draw : 1;     /*1: horizontal scrollbar is visible now (Handled by the library)*/
-        uint8_t ver_draw : 1;     /*1: vertical scrollbar is visible now (Handled by the library)*/
-        lv_scrollbar_mode_t mode : 3;    /*Scrollbar visibility from 'lv_scrollbar_mode_t'*/
-    } scrlbar;
-#if LV_USE_ANIMATION
-    struct {
-        lv_anim_value_t state;    /*Store the current size of the edge flash effect*/
-        lv_style_list_t style; /*Style of edge flash effect (usually homogeneous circle)*/
-        uint8_t enabled : 1;      /*1: Show a flash animation on the edge*/
-        uint8_t top_ip : 1;       /*Used internally to show that top most position is reached (flash is In
-                                     Progress)*/
-        uint8_t bottom_ip : 1;    /*Used internally to show that bottom most position is reached (flash
-                                     is In Progress)*/
-        uint8_t right_ip : 1;     /*Used internally to show that right most position is reached (flash
-                                     is In Progress)*/
-        uint8_t left_ip : 1;      /*Used internally to show that left most position is reached (flash is
-                                     In Progress)*/
-    } edge_flash;
-
-    uint16_t anim_time; /*Scroll animation time*/
-#endif
-    lv_obj_t * scroll_prop_obj;          /*Pointer to child page from where the scroll is being propagated */
-    uint8_t scroll_prop : 1;   /*The direction of the scroll propagation*/
-} lv_page_ext_t;
-
-enum {
-    LV_PAGE_PART_BG = LV_CONT_PART_MAIN,
-    LV_PAGE_PART_SCROLLBAR = _LV_OBJ_PART_VIRTUAL_LAST,
-    LV_PAGE_PART_EDGE_FLASH,
-    _LV_PAGE_PART_VIRTUAL_LAST,
-
-    LV_PAGE_PART_SCROLLABLE = _LV_OBJ_PART_REAL_LAST,
-    _LV_PAGE_PART_REAL_LAST,
-};
-typedef uint8_t lv_part_style_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a page objects
- * @param par pointer to an object, it will be the parent of the new page
- * @param copy pointer to a page object, if not NULL then the new object will be copied from it
- * @return pointer to the created page
- */
-lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param page pointer to an object
- */
-void lv_page_clean(lv_obj_t * page);
-
-/**
- * Get the scrollable object of a page
- * @param page pointer to a page object
- * @return pointer to a container which is the scrollable part of the page
- */
-lv_obj_t * lv_page_get_scrollable(const lv_obj_t * page);
-
-/**
- * Get the animation time
- * @param page pointer to a page object
- * @return the animation time in milliseconds
- */
-uint16_t lv_page_get_anim_time(const lv_obj_t * page);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @param sb_mode the new mode from 'lv_page_sb.mode_t' enum
- */
-void lv_page_set_scrollbar_mode(lv_obj_t * page, lv_scrollbar_mode_t sb_mode);
-
-/**
- * Set the animation time for the page
- * @param page pointer to a page object
- * @param anim_time animation time in milliseconds
- */
-void lv_page_set_anim_time(lv_obj_t * page, uint16_t anim_time);
-
-/**
- * Enable the scroll propagation feature. If enabled then the page will move its parent if there is
- * no more space to scroll.
- * The page needs to have a page-like parent (e.g. `lv_page`, `lv_tabview` tab, `lv_win` content area etc)
- * If enabled drag direction will be changed `LV_DRAG_DIR_ONE` automatically to allow scrolling only in one direction at one time.
- * @param page pointer to a Page
- * @param en true or false to enable/disable scroll propagation
- */
-void lv_page_set_scroll_propagation(lv_obj_t * page, bool en);
-
-/**
- * Enable the edge flash effect. (Show an arc when the an edge is reached)
- * @param page pointer to a Page
- * @param en true or false to enable/disable end flash
- */
-void lv_page_set_edge_flash(lv_obj_t * page, bool en);
-
-/**
- * Set the fit policy in all 4 directions separately.
- * It tell how to change the page size automatically.
- * @param page pointer to a page object
- * @param left left fit policy from `lv_fit_t`
- * @param right right fit policy from `lv_fit_t`
- * @param top bottom fit policy from `lv_fit_t`
- * @param bottom bottom fit policy from `lv_fit_t`
- */
-static inline void lv_page_set_scrollable_fit4(lv_obj_t * page, lv_fit_t left, lv_fit_t right, lv_fit_t top,
-                                               lv_fit_t bottom)
-{
-    lv_cont_set_fit4(lv_page_get_scrollable(page), left, right, top, bottom);
-}
-
-/**
- * Set the fit policy horizontally and vertically separately.
- * It tell how to change the page size automatically.
- * @param page pointer to a page object
- * @param hot horizontal fit policy from `lv_fit_t`
- * @param ver vertical fit policy from `lv_fit_t`
- */
-static inline void lv_page_set_scrollable_fit2(lv_obj_t * page, lv_fit_t hor, lv_fit_t ver)
-{
-    lv_cont_set_fit2(lv_page_get_scrollable(page), hor, ver);
-}
-
-/**
- * Set the fit policy in all 4 direction at once.
- * It tell how to change the page size automatically.
- * @param page pointer to a button object
- * @param fit fit policy from `lv_fit_t`
- */
-static inline void lv_page_set_scrollable_fit(lv_obj_t * page, lv_fit_t fit)
-{
-    lv_cont_set_fit(lv_page_get_scrollable(page), fit);
-}
-
-/**
- * Set width of the scrollable part of a page
- * @param page pointer to a page object
- * @param w the new width of the scrollable (it ha no effect is horizontal fit is enabled)
- */
-static inline void lv_page_set_scrl_width(lv_obj_t * page, lv_coord_t w)
-{
-    lv_obj_set_width(lv_page_get_scrollable(page), w);
-}
-
-/**
- * Set height of the scrollable part of a page
- * @param page pointer to a page object
- * @param h the new height of the scrollable (it ha no effect is vertical fit is enabled)
- */
-static inline void lv_page_set_scrl_height(lv_obj_t * page, lv_coord_t h)
-{
-    lv_obj_set_height(lv_page_get_scrollable(page), h);
-}
-
-/**
- * Set the layout of the scrollable part of the page
- * @param page pointer to a page object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-static inline void lv_page_set_scrl_layout(lv_obj_t * page, lv_layout_t layout)
-{
-    lv_cont_set_layout(lv_page_get_scrollable(page), layout);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @return the mode from 'lv_page_sb.mode_t' enum
- */
-lv_scrollbar_mode_t lv_page_get_scrollbar_mode(const lv_obj_t * page);
-
-/**
- * Get the scroll propagation property
- * @param page pointer to a Page
- * @return true or false
- */
-bool lv_page_get_scroll_propagation(lv_obj_t * page);
-
-/**
- * Get the edge flash effect property.
- * @param page pointer to a Page
- * return true or false
- */
-bool lv_page_get_edge_flash(lv_obj_t * page);
-
-/**
- * Get that width which can be set to the children to still not cause overflow (show scrollbars)
- * @param page pointer to a page object
- * @return the width which still fits into the page
- */
-lv_coord_t lv_page_get_width_fit(lv_obj_t * page);
-
-/**
- * Get that height which can be set to the children to still not cause overflow (show scrollbars)
- * @param page pointer to a page object
- * @return the height which still fits into the page
- */
-lv_coord_t lv_page_get_height_fit(lv_obj_t * page);
-
-/**
- * Divide the width of the object and get the width of a given number of columns.
- * Take into account the paddings of the background and scrollable too.
- * @param page pointer to an object
- * @param div indicates how many columns are assumed.
- * If 1 the width will be set the the parent's width
- * If 2 only half parent width - inner padding of the parent
- * If 3 only third parent width - 2 * inner padding of the parent
- * @param span how many columns are combined
- * @return the width according to the given parameters
- */
-lv_coord_t lv_page_get_width_grid(lv_obj_t * page, uint8_t div, uint8_t span);
-
-/**
- * Divide the height of the object and get the width of a given number of columns.
- * Take into account the paddings of the background and scrollable too.
- * @param page pointer to an object
- * @param div indicates how many rows are assumed.
- * If 1 the height will be set the the parent's height
- * If 2 only half parent height - inner padding of the parent
- * If 3 only third parent height - 2 * inner padding of the parent
- * @param span how many rows are combined
- * @return the height according to the given parameters
- */
-lv_coord_t lv_page_get_height_grid(lv_obj_t * page, uint8_t div, uint8_t span);
-
-/**
- * Get width of the scrollable part of a page
- * @param page pointer to a page object
- * @return the width of the scrollable
- */
-static inline lv_coord_t lv_page_get_scrl_width(const lv_obj_t * page)
-{
-    return lv_obj_get_width(lv_page_get_scrollable(page));
-}
-
-/**
- * Get height of the scrollable part of a page
- * @param page pointer to a page object
- * @return the height of the scrollable
- */
-static inline lv_coord_t lv_page_get_scrl_height(const lv_obj_t * page)
-{
-    return lv_obj_get_height(lv_page_get_scrollable(page));
-}
-
-/**
- * Get the layout of the scrollable part of a page
- * @param page pointer to page object
- * @return the layout from 'lv_cont_layout_t'
- */
-static inline lv_layout_t lv_page_get_scrl_layout(const lv_obj_t * page)
-{
-    return lv_cont_get_layout(lv_page_get_scrollable(page));
-}
-
-/**
- * Get the left fit mode
- * @param page pointer to a page object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_page_get_scrl_fit_left(const lv_obj_t * page)
-{
-    return lv_cont_get_fit_left(lv_page_get_scrollable(page));
-}
-
-/**
- * Get the right fit mode
- * @param page pointer to a page object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_page_get_scrl_fit_right(const lv_obj_t * page)
-{
-    return lv_cont_get_fit_right(lv_page_get_scrollable(page));
-}
-
-/**
- * Get the top fit mode
- * @param page pointer to a page object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_page_get_scrl_fit_top(const lv_obj_t * page)
-{
-    return lv_cont_get_fit_top(lv_page_get_scrollable(page));
-}
-
-/**
- * Get the bottom fit mode
- * @param page pointer to a page object
- * @return an element of `lv_fit_t`
- */
-static inline lv_fit_t lv_page_get_scrl_fit_bottom(const lv_obj_t * page)
-{
-    return lv_cont_get_fit_bottom(lv_page_get_scrollable(page));
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Find whether the page has been scrolled to a certain edge.
- * @param page Page object
- * @param edge Edge to check
- * @return true if the page is on the specified edge
- */
-bool lv_page_on_edge(lv_obj_t * page, lv_page_edge_t edge);
-
-/**
- * Glue the object to the page. After it the page can be moved (dragged) with this object too.
- * @param page pointer to a page object
- * @param obj pointer to an object on a page
- * @param glue true: enable glue, false: disable glue
- */
-void lv_page_glue_obj(lv_obj_t * page, lv_obj_t * obj, bool glue);
-
-/**
- * Focus on an object. It ensures that the object will be visible on the page.
- * @param page pointer to a page object
- * @param obj pointer to an object to focus (must be on the page)
- * @param anim_en LV_ANIM_ON to focus with animation; LV_ANIM_OFF to focus without animation
- */
-void lv_page_focus(lv_obj_t * page, const lv_obj_t * obj, lv_anim_enable_t anim_en);
-
-/**
- * Scroll the page horizontally
- * @param page pointer to a page object
- * @param dist the distance to scroll (< 0: scroll left; > 0 scroll right)
- */
-void lv_page_scroll_hor(lv_obj_t * page, lv_coord_t dist);
-
-/**
- * Scroll the page vertically
- * @param page pointer to a page object
- * @param dist the distance to scroll (< 0: scroll down; > 0 scroll up)
- */
-void lv_page_scroll_ver(lv_obj_t * page, lv_coord_t dist);
-
-/**
- * Not intended to use directly by the user but by other object types internally.
- * Start an edge flash animation.
- * @param page
- * @param edge the edge to flash. Can be `LV_PAGE_EDGE_LEFT/RIGHT/TOP/BOTTOM`
- */
-void lv_page_start_edge_flash(lv_obj_t * page, lv_page_edge_t edge);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_PAGE*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_PAGE_H*/
diff --git a/src/lv_widgets/lv_spinbox.c b/src/lv_widgets/lv_spinbox.c
deleted file mode 100644
index 28f2de153..000000000
--- a/src/lv_widgets/lv_spinbox.c
+++ /dev/null
@@ -1,603 +0,0 @@
-/**
- * @file lv_spinbox.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_spinbox.h"
-
-#if LV_USE_SPINBOX != 0
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_math.h"
-#include "../lv_misc/lv_utils.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_spinbox"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_spinbox_get_style(lv_obj_t * ta, uint8_t part);
-static void lv_spinbox_updatevalue(lv_obj_t * spinbox);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a spinbox object
- * @param par pointer to an object, it will be the parent of the new spinbox
- * @param copy pointer to a spinbox object, if not NULL then the new object will be copied from it
- * @return pointer to the created spinbox
- */
-lv_obj_t * lv_spinbox_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("spinbox create started");
-
-    /*Create the ancestor of spinbox*/
-    lv_obj_t * spinbox = lv_textarea_create(par, copy);
-    LV_ASSERT_MEM(spinbox);
-    if(spinbox == NULL) return NULL;
-
-    /*Allocate the spinbox type specific extended data*/
-    lv_spinbox_ext_t * ext = lv_obj_allocate_ext_attr(spinbox, sizeof(lv_spinbox_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(spinbox);
-        return NULL;
-    }
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(spinbox);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(spinbox);
-
-    /*Initialize the allocated 'ext'*/
-    ext->value              = 0;
-    ext->dec_point_pos      = 0;
-    ext->digit_count        = 5;
-    ext->digit_padding_left = 0;
-    ext->step               = 1;
-    ext->range_max          = 99999;
-    ext->range_min          = -99999;
-    ext->rollover           = false;
-
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(spinbox, lv_spinbox_signal);
-    lv_obj_set_design_cb(spinbox, ancestor_design); /*Leave the Text area's design function*/
-
-    /*Init the new spinbox*/
-    if(copy == NULL) {
-        /* No scrolling will happen here so make the scrollable non-clickable
-         * It allows to handle input events in the bg object only.*/
-        lv_obj_set_click(lv_page_get_scrollable(spinbox), false);
-        lv_textarea_set_one_line(spinbox, true);
-        lv_textarea_set_cursor_click_pos(spinbox, true);
-        lv_obj_set_width(spinbox, LV_DPI);
-        lv_theme_apply(spinbox, LV_THEME_SPINBOX);
-    }
-    /*Copy an existing spinbox*/
-    else {
-        lv_spinbox_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-
-        lv_spinbox_set_value(spinbox, copy_ext->value);
-        lv_spinbox_set_digit_format(spinbox, (uint8_t)copy_ext->digit_count, (uint8_t)copy_ext->dec_point_pos);
-        lv_spinbox_set_range(spinbox, copy_ext->range_min, copy_ext->range_max);
-        lv_spinbox_set_step(spinbox, copy_ext->step);
-        lv_spinbox_set_rollover(spinbox, copy_ext->rollover);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(spinbox, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    lv_spinbox_updatevalue(spinbox);
-
-    LV_LOG_INFO("spinbox created");
-
-    return spinbox;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set spinbox rollover function
- * @param spinbox pointer to spinbox
- * @param b true or false to enable or disable (default)
- */
-void lv_spinbox_set_rollover(lv_obj_t * spinbox, bool b)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    ext->rollover = b;
-}
-
-/**
- * Set spinbox value
- * @param spinbox pointer to spinbox
- * @param i value to be set
- */
-void lv_spinbox_set_value(lv_obj_t * spinbox, int32_t i)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-    if(ext == NULL) return;
-
-    if(i > ext->range_max) i = ext->range_max;
-    if(i < ext->range_min) i = ext->range_min;
-
-    ext->value = i;
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Set spinbox digit format (digit count and decimal format)
- * @param spinbox pointer to spinbox
- * @param digit_count number of digit excluding the decimal separator and the sign
- * @param separator_position number of digit before the decimal point. If 0, decimal point is not
- * shown
- */
-void lv_spinbox_set_digit_format(lv_obj_t * spinbox, uint8_t digit_count, uint8_t separator_position)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-    if(ext == NULL) return;
-
-    if(digit_count > LV_SPINBOX_MAX_DIGIT_COUNT) digit_count = LV_SPINBOX_MAX_DIGIT_COUNT;
-
-    if(separator_position >= digit_count) separator_position = 0;
-    if(separator_position > LV_SPINBOX_MAX_DIGIT_COUNT) separator_position = LV_SPINBOX_MAX_DIGIT_COUNT;
-
-    if(digit_count < LV_SPINBOX_MAX_DIGIT_COUNT) {
-        int64_t max_val = _lv_pow(10, digit_count);
-        if(ext->range_max > max_val - 1) ext->range_max = max_val - 1;
-        if(ext->range_min < - max_val  + 1) ext->range_min = - max_val  + 1;
-    }
-
-    ext->digit_count   = digit_count;
-    ext->dec_point_pos = separator_position;
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Set spinbox step
- * @param spinbox pointer to spinbox
- * @param step steps on increment/decrement
- */
-void lv_spinbox_set_step(lv_obj_t * spinbox, uint32_t step)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-    if(ext == NULL) return;
-
-    ext->step = step;
-}
-
-/**
- * Set spinbox value range
- * @param spinbox pointer to spinbox
- * @param range_min maximum value, inclusive
- * @param range_max minimum value, inclusive
- */
-void lv_spinbox_set_range(lv_obj_t * spinbox, int32_t range_min, int32_t range_max)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-    if(ext == NULL) return;
-
-    ext->range_max = range_max;
-    ext->range_min = range_min;
-
-    if(ext->value > ext->range_max) {
-        ext->value = ext->range_max;
-        lv_obj_invalidate(spinbox);
-    }
-    if(ext->value < ext->range_min) {
-        ext->value = ext->range_min;
-        lv_obj_invalidate(spinbox);
-    }
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Set spinbox left padding in digits count (added between sign and first digit)
- * @param spinbox pointer to spinbox
- * @param cb Callback function called on value change event
- */
-void lv_spinbox_set_padding_left(lv_obj_t * spinbox, uint8_t padding)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext  = lv_obj_get_ext_attr(spinbox);
-    ext->digit_padding_left = padding;
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get spinbox rollover function status
- * @param spinbox pointer to spinbox
- */
-bool lv_spinbox_get_rollover(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    return ext->rollover;
-}
-
-/**
- * Get the spinbox numeral value (user has to convert to float according to its digit format)
- * @param spinbox pointer to spinbox
- * @return value integer value of the spinbox
- */
-int32_t lv_spinbox_get_value(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    return ext->value;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Select next lower digit for edition
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_step_next(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    int32_t new_step = ext->step / 10;
-    if((new_step) > 0)
-        ext->step = new_step;
-    else
-        ext->step = 1;
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Select next higher digit for edition
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_step_prev(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-    int32_t step_limit;
-    step_limit       = LV_MATH_MAX(ext->range_max, (ext->range_min < 0 ? (-ext->range_min) : ext->range_min));
-    int32_t new_step = ext->step * 10;
-    if(new_step <= step_limit) ext->step = new_step;
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Increment spinbox value by one step
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_increment(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    if(ext->value + ext->step <= ext->range_max) {
-        /*Special mode when zero crossing*/
-        if((ext->value + ext->step) > 0 && ext->value < 0) ext->value = -ext->value;
-        ext->value += ext->step;
-
-    }
-    else {
-        // Rollover?
-        if((ext->rollover) && (ext->value == ext->range_max))
-            ext->value = ext->range_min;
-        else
-            ext->value = ext->range_max;
-    }
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**
- * Decrement spinbox value by one step
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_decrement(lv_obj_t * spinbox)
-{
-    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    if(ext->value - ext->step >= ext->range_min) {
-        /*Special mode when zero crossing*/
-        if((ext->value - ext->step) < 0 && ext->value > 0) ext->value = -ext->value;
-        ext->value -= ext->step;
-    }
-    else {
-        // Rollover?
-        if((ext->rollover) && (ext->value == ext->range_min))
-            ext->value = ext->range_max;
-        else
-            ext->value = ext->range_min;
-    }
-
-    lv_spinbox_updatevalue(spinbox);
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the spinbox
- * @param spinbox pointer to a spinbox object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * param)
-{
-
-    lv_res_t res = LV_RES_OK;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_spinbox_get_style(spinbox, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(spinbox, sign, param);
-    }
-
-    /* Include the ancient signal function */
-    if(sign != LV_SIGNAL_CONTROL) {
-        res = ancestor_signal(spinbox, sign, param);
-        if(res != LV_RES_OK) return res;
-    }
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    }
-    else if(sign == LV_SIGNAL_GET_TYPE) {
-        lv_obj_type_t * buf = param;
-        uint8_t i;
-        for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
-            if(buf->type[i] == NULL) break;
-        }
-        buf->type[i] = "lv_spinbox";
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        /*If released with an ENCODER then move to the next digit*/
-        lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-        lv_indev_t * indev = lv_indev_get_act();
-        if(lv_indev_get_type(indev) == LV_INDEV_TYPE_ENCODER) {
-#if LV_USE_GROUP
-            if(lv_group_get_editing(lv_obj_get_group(spinbox))) {
-                if(ext->step > 1) {
-                    lv_spinbox_step_next(spinbox);
-                }
-                else {
-                    /*Restart from the MSB*/
-                    ext->step = 1;
-                    uint32_t i;
-                    for(i = 0; i < ext->digit_count; i++) {
-                        int32_t new_step = ext->step * 10;
-                        if(new_step >= ext->range_max) break;
-                        ext->step = new_step;
-                    }
-                    lv_spinbox_step_prev(spinbox);
-                }
-            }
-#endif
-        }
-        else {
-            /*The cursor has been positioned to a digit.
-             * Set `step` accordingly*/
-            const char * txt = lv_textarea_get_text(spinbox);
-            size_t txt_len = strlen(txt);
-
-            if(txt[ext->ta.cursor.pos] == '.') {
-                lv_textarea_cursor_left(spinbox);
-            }
-            else if(ext->ta.cursor.pos == (uint32_t)txt_len) {
-                lv_textarea_set_cursor_pos(spinbox, txt_len - 1);
-            }
-            else if(ext->ta.cursor.pos == 0 && ext->range_min < 0) {
-                lv_textarea_set_cursor_pos(spinbox, 1);
-            }
-
-            size_t len = ext->digit_count - 1;
-            uint16_t cp = ext->ta.cursor.pos;
-
-            if(ext->ta.cursor.pos > ext->dec_point_pos && ext->dec_point_pos != 0) cp--;
-            uint32_t pos = len - cp;
-
-            if(ext->range_min < 0) pos++;
-
-            ext->step = 1;
-            uint16_t i;
-            for(i = 0; i < pos; i++) ext->step *= 10;
-
-
-
-        }
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        lv_indev_type_t indev_type = lv_indev_get_type(lv_indev_get_act());
-
-        uint32_t c = *((uint32_t *)param); /*uint32_t because can be UTF-8*/
-        if(c == LV_KEY_RIGHT) {
-            if(indev_type == LV_INDEV_TYPE_ENCODER)
-                lv_spinbox_increment(spinbox);
-            else
-                lv_spinbox_step_next(spinbox);
-        }
-        else if(c == LV_KEY_LEFT) {
-            if(indev_type == LV_INDEV_TYPE_ENCODER)
-                lv_spinbox_decrement(spinbox);
-            else
-                lv_spinbox_step_prev(spinbox);
-        }
-        else if(c == LV_KEY_UP) {
-            lv_spinbox_increment(spinbox);
-        }
-        else if(c == LV_KEY_DOWN) {
-            lv_spinbox_decrement(spinbox);
-        }
-        else {
-            lv_textarea_add_char(spinbox, c);
-        }
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param page pointer the object
- * @param part the part from `lv_spinbox_part_t`. (LV_SPINBOX_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_spinbox_get_style(lv_obj_t * ta, uint8_t part)
-{
-    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
-
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(ta);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_SPINBOX_PART_BG:
-            style_dsc_p = &ta->style_list;
-            break;
-        case LV_SPINBOX_PART_CURSOR:
-            style_dsc_p = &ext->ta.cursor.style;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-static void lv_spinbox_updatevalue(lv_obj_t * spinbox)
-{
-    lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
-
-    char buf[LV_SPINBOX_MAX_DIGIT_COUNT + 8];
-    _lv_memset_00(buf, sizeof(buf));
-    char * buf_p = buf;
-    uint8_t cur_shift_left = 0;
-
-    if(ext->range_min < 0) {  // hide sign if there are only positive values
-        /*Add the sign*/
-        (*buf_p) = ext->value >= 0 ? '+' : '-';
-        buf_p++;
-    }
-    else {
-        /*Cursor need shift to left*/
-        cur_shift_left++;
-    }
-
-    int32_t i;
-    /*padding left*/
-    for(i = 0; i < ext->digit_padding_left; i++) {
-        (*buf_p) = ' ';
-        buf_p++;
-    }
-
-    char digits[64];
-    /*Convert the numbers to string (the sign is already handled so always covert positive number)*/
-    _lv_utils_num_to_str(ext->value < 0 ? -ext->value : ext->value, digits);
-
-    /*Add leading zeros*/
-    int lz_cnt = ext->digit_count - (int)strlen(digits);
-    if(lz_cnt > 0) {
-        for(i = (uint16_t)strlen(digits); i >= 0; i--) {
-            digits[i + lz_cnt] = digits[i];
-        }
-        for(i = 0; i < lz_cnt; i++) {
-            digits[i] = '0';
-        }
-    }
-
-    int32_t intDigits;
-    intDigits = (ext->dec_point_pos == 0) ? ext->digit_count : ext->dec_point_pos;
-
-    /*Add the decimal part*/
-    for(i = 0; i < intDigits && digits[i] != '\0'; i++) {
-        (*buf_p) = digits[i];
-        buf_p++;
-    }
-
-    if(ext->dec_point_pos != 0) {
-        /*Insert the decimal point*/
-        (*buf_p) = '.';
-        buf_p++;
-
-        for(/*Leave i*/; i < ext->digit_count && digits[i] != '\0'; i++) {
-            (*buf_p) = digits[i];
-            buf_p++;
-        }
-    }
-
-    /*Refresh the text*/
-    lv_textarea_set_text(spinbox, (char *)buf);
-
-    /*Set the cursor position*/
-    int32_t step    = ext->step;
-    uint8_t cur_pos = (uint8_t)ext->digit_count;
-    while(step >= 10) {
-        step /= 10;
-        cur_pos--;
-    }
-
-    if(cur_pos > intDigits) cur_pos++; /*Skip the decimal point*/
-
-    cur_pos += (ext->digit_padding_left - cur_shift_left);
-
-    lv_textarea_set_cursor_pos(spinbox, cur_pos);
-}
-
-#endif
diff --git a/src/lv_widgets/lv_spinbox.h b/src/lv_widgets/lv_spinbox.h
deleted file mode 100644
index 83c057f58..000000000
--- a/src/lv_widgets/lv_spinbox.h
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- * @file lv_spinbox.h
- *
- */
-
-#ifndef LV_SPINBOX_H
-#define LV_SPINBOX_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_SPINBOX != 0
-
-/*Testing of dependencies*/
-#if LV_USE_TEXTAREA == 0
-#error "lv_spinbox: lv_ta is required. Enable it in lv_conf.h (LV_USE_TEXTAREA  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "../lv_widgets/lv_textarea.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_SPINBOX_MAX_DIGIT_COUNT 10
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of spinbox*/
-typedef struct {
-    lv_textarea_ext_t ta; /*Ext. of ancestor*/
-    /*New data for this type */
-    int32_t value;
-    int32_t range_max;
-    int32_t range_min;
-    int32_t step;
-    uint8_t rollover : 1;   // Set to true for rollover functionality
-    uint16_t digit_count : 4;
-    uint16_t dec_point_pos : 4; /*if 0, there is no separator and the number is an integer*/
-    uint16_t digit_padding_left : 4;
-} lv_spinbox_ext_t;
-
-/*Styles*/
-enum {
-    LV_SPINBOX_PART_BG = LV_TEXTAREA_PART_BG,
-    LV_SPINBOX_PART_CURSOR = LV_TEXTAREA_PART_CURSOR,
-    _LV_SPINBOX_PART_VIRTUAL_LAST = _LV_TEXTAREA_PART_VIRTUAL_LAST,
-    _LV_SPINBOX_PART_REAL_LAST = _LV_TEXTAREA_PART_REAL_LAST,
-};
-typedef uint8_t lv_spinbox_part_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a spinbox objects
- * @param par pointer to an object, it will be the parent of the new spinbox
- * @param copy pointer to a spinbox object, if not NULL then the new object will be copied from it
- * @return pointer to the created spinbox
- */
-lv_obj_t * lv_spinbox_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set spinbox rollover function
- * @param spinbox pointer to spinbox
- * @param b true or false to enable or disable (default)
- */
-void lv_spinbox_set_rollover(lv_obj_t * spinbox, bool b);
-
-/**
- * Set spinbox value
- * @param spinbox pointer to spinbox
- * @param i value to be set
- */
-void lv_spinbox_set_value(lv_obj_t * spinbox, int32_t i);
-
-/**
- * Set spinbox digit format (digit count and decimal format)
- * @param spinbox pointer to spinbox
- * @param digit_count number of digit excluding the decimal separator and the sign
- * @param separator_position number of digit before the decimal point. If 0, decimal point is not
- * shown
- */
-void lv_spinbox_set_digit_format(lv_obj_t * spinbox, uint8_t digit_count, uint8_t separator_position);
-
-/**
- * Set spinbox step
- * @param spinbox pointer to spinbox
- * @param step steps on increment/decrement
- */
-void lv_spinbox_set_step(lv_obj_t * spinbox, uint32_t step);
-
-/**
- * Set spinbox value range
- * @param spinbox pointer to spinbox
- * @param range_min maximum value, inclusive
- * @param range_max minimum value, inclusive
- */
-void lv_spinbox_set_range(lv_obj_t * spinbox, int32_t range_min, int32_t range_max);
-
-/**
- * Set spinbox left padding in digits count (added between sign and first digit)
- * @param spinbox pointer to spinbox
- * @param cb Callback function called on value change event
- */
-void lv_spinbox_set_padding_left(lv_obj_t * spinbox, uint8_t padding);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get spinbox rollover function status
- * @param spinbox pointer to spinbox
- */
-bool lv_spinbox_get_rollover(lv_obj_t * spinbox);
-
-/**
- * Get the spinbox numeral value (user has to convert to float according to its digit format)
- * @param spinbox pointer to spinbox
- * @return value integer value of the spinbox
- */
-int32_t lv_spinbox_get_value(lv_obj_t * spinbox);
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Select next lower digit for edition by dividing the step by 10
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_step_next(lv_obj_t * spinbox);
-
-/**
- * Select next higher digit for edition by multiplying the step by 10
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_step_prev(lv_obj_t * spinbox);
-
-/**
- * Increment spinbox value by one step
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_increment(lv_obj_t * spinbox);
-
-/**
- * Decrement spinbox value by one step
- * @param spinbox pointer to spinbox
- */
-void lv_spinbox_decrement(lv_obj_t * spinbox);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_SPINBOX*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_SPINBOX_H*/
diff --git a/src/lv_widgets/lv_spinner.c b/src/lv_widgets/lv_spinner.c
deleted file mode 100644
index 8e0e2dcd0..000000000
--- a/src/lv_widgets/lv_spinner.c
+++ /dev/null
@@ -1,326 +0,0 @@
-/**
- * @file lv_spinner.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_spinner.h"
-#if LV_USE_SPINNER != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_misc/lv_math.h"
-#include "../lv_draw/lv_draw_rect.h"
-#include "../lv_draw/lv_draw_arc.h"
-#include "../lv_themes/lv_theme.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_spinner"
-
-#ifndef LV_SPINNER_DEF_ARC_LENGTH
-    #define LV_SPINNER_DEF_ARC_LENGTH 60 /*[deg]*/
-#endif
-
-#ifndef LV_SPINNER_DEF_SPIN_TIME
-    #define LV_SPINNER_DEF_SPIN_TIME 1000 /*[ms]*/
-#endif
-
-#ifndef LV_SPINNER_DEF_ANIM
-    #define LV_SPINNER_DEF_ANIM LV_SPINNER_TYPE_SPINNING_ARC /*animation type*/
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_spinner_signal(lv_obj_t * spinner, lv_signal_t sign, void * param);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a spinner object
- * @param par pointer to an object, it will be the parent of the new spinner
- * @param copy pointer to a spinner object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created spinner
- */
-lv_obj_t * lv_spinner_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("spinner create started");
-
-    /*Create the ancestor of spinner*/
-    lv_obj_t * spinner = lv_arc_create(par, copy);
-    LV_ASSERT_MEM(spinner);
-    if(spinner == NULL) return NULL;
-
-    /*Allocate the spinner type specific extended data*/
-    lv_spinner_ext_t * ext = lv_obj_allocate_ext_attr(spinner, sizeof(lv_spinner_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(spinner);
-        return NULL;
-    }
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(spinner);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(spinner);
-
-    /*Initialize the allocated 'ext' */
-    ext->arc_length = LV_SPINNER_DEF_ARC_LENGTH;
-    ext->anim_type  = LV_SPINNER_DEF_ANIM;
-    ext->anim_dir   = LV_SPINNER_DIR_FORWARD;
-    ext->time = LV_SPINNER_DEF_SPIN_TIME;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(spinner, lv_spinner_signal);
-
-    /*Init the new spinner spinner*/
-    if(copy == NULL) {
-        ext->arc.bg_angle_start = 0;
-        ext->arc.bg_angle_end = 360;
-        lv_obj_set_size(spinner, LV_DPI, LV_DPI);
-        lv_theme_apply(spinner, LV_THEME_SPINNER);
-
-    }
-    /*Copy an existing spinner*/
-    else {
-        lv_spinner_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->arc_length             = copy_ext->arc_length;
-        ext->time                   = copy_ext->time;
-        ext->anim_dir               = copy_ext->anim_dir;
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(spinner, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    lv_spinner_set_type(spinner, ext->anim_type);
-
-    LV_LOG_INFO("spinner created");
-
-    return spinner;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Set the length of the spinning  arc in degrees
- * @param spinner pointer to a spinner object
- * @param deg length of the arc
- */
-void lv_spinner_set_arc_length(lv_obj_t * spinner, lv_anim_value_t deg)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-
-    ext->arc_length = deg;
-}
-
-/**
- * Set the spin time of the arc
- * @param spinner pointer to a spinner object
- * @param time time of one round in milliseconds
- */
-void lv_spinner_set_spin_time(lv_obj_t * spinner, uint16_t time)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-
-    ext->time = time;
-    lv_spinner_set_type(spinner, ext->anim_type);
-}
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the animation type of a spinner.
- * @param spinner pointer to spinner object
- * @param type animation type of the spinner
- *  */
-void lv_spinner_set_type(lv_obj_t * spinner, lv_spinner_type_t type)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-
-    /*delete previous animation*/
-    lv_anim_del(spinner, NULL);
-    switch(type) {
-        case LV_SPINNER_TYPE_FILLSPIN_ARC: {
-                ext->anim_type = LV_SPINNER_TYPE_FILLSPIN_ARC;
-                lv_anim_path_t path;
-                lv_anim_path_init(&path);
-                lv_anim_path_set_cb(&path, lv_anim_path_ease_in_out);
-
-                lv_anim_t a;
-                lv_anim_init(&a);
-                lv_anim_set_var(&a, spinner);
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_spinner_anim_cb);
-                lv_anim_set_path(&a, &path);
-                lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
-                lv_anim_set_time(&a, ext->time);
-                if(ext->anim_dir == LV_SPINNER_DIR_FORWARD) lv_anim_set_values(&a, 0, 360);
-                else lv_anim_set_values(&a, 360, 0);
-                lv_anim_start(&a);
-
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_spinner_set_arc_length);
-                if(ext->anim_dir == LV_SPINNER_DIR_FORWARD) lv_anim_set_values(&a, ext->arc_length, 360 - ext->arc_length);
-                else lv_anim_set_values(&a, 360 - ext->arc_length, ext->arc_length);
-
-                lv_anim_set_playback_time(&a, ext->time);
-                lv_anim_start(&a);
-                break;
-            }
-        case LV_SPINNER_TYPE_CONSTANT_ARC:
-        case LV_SPINNER_TYPE_SPINNING_ARC:
-        default: {
-                ext->anim_type = type;
-
-                lv_anim_path_t path;
-                lv_anim_path_init(&path);
-                lv_anim_path_set_cb(&path, (LV_SPINNER_TYPE_CONSTANT_ARC == type ? lv_anim_path_linear : lv_anim_path_ease_in_out));
-
-                lv_anim_t a;
-                lv_anim_init(&a);
-                lv_anim_set_var(&a, spinner);
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_spinner_anim_cb);
-                lv_anim_set_time(&a, ext->time);
-                lv_anim_set_path(&a, &path);
-                lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
-                if(ext->anim_dir == LV_SPINNER_DIR_FORWARD) lv_anim_set_values(&a, 0, 360);
-                else lv_anim_set_values(&a, 360, 0);
-                lv_anim_start(&a);
-                break;
-            }
-    }
-}
-
-void lv_spinner_set_dir(lv_obj_t * spinner, lv_spinner_dir_t dir)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-
-    ext->anim_dir = dir;
-    lv_spinner_set_type(spinner, ext->anim_type);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the arc length [degree] of the a spinner
- * @param spinner pointer to a spinner object
- */
-lv_anim_value_t lv_spinner_get_arc_length(const lv_obj_t * spinner)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-    return ext->arc_length;
-}
-
-/**
- * Get the spin time of the arc
- * @param spinner pointer to a spinner object [milliseconds]
- */
-uint16_t lv_spinner_get_spin_time(const lv_obj_t * spinner)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-    return ext->time;
-}
-
-/**
- * Get the animation type of a spinner.
- * @param spinner pointer to spinner object
- * @return animation type
- *  */
-lv_spinner_type_t lv_spinner_get_type(lv_obj_t * spinner)
-{
-    LV_ASSERT_OBJ(spinner, LV_OBJX_NAME);
-
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-    return ext->anim_type;
-}
-
-lv_spinner_dir_t lv_spinner_get_dir(lv_obj_t * spinner)
-{
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-    return ext->anim_dir;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Animator function  (exec_cb) to rotate the arc of spinner.
- * @param ptr pointer to spinner
- * @param val the current desired value [0..360]
- */
-void lv_spinner_anim_cb(void * ptr, lv_anim_value_t val)
-{
-    lv_obj_t * spinner     = ptr;
-    lv_spinner_ext_t * ext = lv_obj_get_ext_attr(spinner);
-
-    int16_t angle_start = val - ext->arc_length / 2 - 90;
-    if(angle_start < 0) angle_start += 360;
-    int16_t angle_end   = angle_start + ext->arc_length;
-
-    angle_start = angle_start % 360;
-    angle_end   = angle_end % 360;
-
-    lv_arc_set_angles(spinner, angle_start, angle_end);
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the spinner
- * @param spinner pointer to a spinner object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_spinner_signal(lv_obj_t * spinner, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(spinner, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    }
-
-    return res;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_spinner.h b/src/lv_widgets/lv_spinner.h
deleted file mode 100644
index 6649202e4..000000000
--- a/src/lv_widgets/lv_spinner.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * @file lv_spinner.h
- *
- */
-
-#ifndef LV_SPINNER_H
-#define LV_SPINNER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_SPINNER != 0
-
-/*Testing of dependencies*/
-#if LV_USE_ARC == 0
-#error "lv_spinner: lv_arc is required. Enable it in lv_conf.h (LV_USE_ARC  1) "
-#endif
-
-#if LV_USE_ANIMATION == 0
-#error "lv_spinner: animations are required. Enable it in lv_conf.h (LV_USE_ANIMATION  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "../lv_misc/lv_anim.h"
-#include "lv_arc.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**
- * Type of spinner.
- */
-enum {
-    LV_SPINNER_TYPE_SPINNING_ARC,
-    LV_SPINNER_TYPE_FILLSPIN_ARC,
-    LV_SPINNER_TYPE_CONSTANT_ARC,
-};
-typedef uint8_t lv_spinner_type_t;
-
-/**
- * Direction the spinner should spin.
- */
-enum {
-    LV_SPINNER_DIR_FORWARD,
-    LV_SPINNER_DIR_BACKWARD,
-};
-typedef uint8_t lv_spinner_dir_t;
-
-/*Data of spinner*/
-typedef struct {
-    lv_arc_ext_t arc; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_anim_value_t arc_length;      /*Length of the spinning indicator in degree*/
-    uint16_t time;                   /*Time of one round*/
-    lv_spinner_type_t anim_type : 2; /*Type of the arc animation*/
-    lv_spinner_dir_t anim_dir : 1;   /*Animation Direction*/
-} lv_spinner_ext_t;
-
-/*Parts of the spinner*/
-enum {
-    LV_SPINNER_PART_BG = LV_ARC_PART_BG,
-    LV_SPINNER_PART_INDIC = LV_ARC_PART_INDIC,
-    _LV_SPINNER_PART_VIRTUAL_LAST,
-
-    _LV_SPINNER_PART_REAL_LAST = _LV_ARC_PART_REAL_LAST,
-};
-typedef uint8_t lv_spinner_style_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a spinner object
- * @param par pointer to an object, it will be the parent of the new spinner
- * @param copy pointer to a spinner object, if not NULL then the new object will be copied from
- * it
- * @return pointer to the created spinner
- */
-lv_obj_t * lv_spinner_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Set the length of the spinning  arc in degrees
- * @param spinner pointer to a spinner object
- * @param deg length of the arc
- */
-void lv_spinner_set_arc_length(lv_obj_t * spinner, lv_anim_value_t deg);
-
-/**
- * Set the spin time of the arc
- * @param spinner pointer to a spinner object
- * @param time time of one round in milliseconds
- */
-void lv_spinner_set_spin_time(lv_obj_t * spinner, uint16_t time);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the animation type of a spinner.
- * @param spinner pointer to spinner object
- * @param type animation type of the spinner
- *  */
-void lv_spinner_set_type(lv_obj_t * spinner, lv_spinner_type_t type);
-
-/**
- * Set the animation direction of a spinner
- * @param spinner pointer to spinner object
- * @param direction animation direction of the spinner
- */
-void lv_spinner_set_dir(lv_obj_t * spinner, lv_spinner_dir_t dir);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the arc length [degree] of the a spinner
- * @param spinner pointer to a spinner object
- */
-lv_anim_value_t lv_spinner_get_arc_length(const lv_obj_t * spinner);
-
-/**
- * Get the spin time of the arc
- * @param spinner pointer to a spinner object [milliseconds]
- */
-uint16_t lv_spinner_get_spin_time(const lv_obj_t * spinner);
-
-/**
- * Get the animation type of a spinner.
- * @param spinner pointer to spinner object
- * @return animation type
- *  */
-lv_spinner_type_t lv_spinner_get_type(lv_obj_t * spinner);
-
-/**
- * Get the animation direction of a spinner
- * @param spinner pointer to spinner object
- * @return animation direction
- */
-lv_spinner_dir_t lv_spinner_get_dir(lv_obj_t * spinner);
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Animator function  (exec_cb) to rotate the arc of spinner.
- * @param ptr pointer to spinner
- * @param val the current desired value [0..360]
- */
-void lv_spinner_anim_cb(void * ptr, lv_anim_value_t val);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_SPINNER*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_SPINNER_H*/
diff --git a/src/lv_widgets/lv_tabview.c b/src/lv_widgets/lv_tabview.c
deleted file mode 100644
index 5cc773444..000000000
--- a/src/lv_widgets/lv_tabview.c
+++ /dev/null
@@ -1,1033 +0,0 @@
-/**
- * @file lv_tab.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_tabview.h"
-#if LV_USE_TABVIEW != 0
-
-#include "lv_btnmatrix.h"
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_anim.h"
-#include "../lv_core/lv_disp.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_tabview"
-
-#if LV_USE_ANIMATION
-    #ifndef LV_TABVIEW_DEF_ANIM_TIME
-        #define LV_TABVIEW_DEF_ANIM_TIME 300 /*Animation time of focusing to the a list element [ms] (0: no animation)  */
-    #endif
-#else
-    #undef LV_TABVIEW_DEF_ANIM_TIME
-    #define LV_TABVIEW_DEF_ANIM_TIME 0 /*No animations*/
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * param);
-static lv_res_t tabview_scrl_signal(lv_obj_t * tabview_scrl, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_tabview_get_style(lv_obj_t * tabview, uint8_t part);
-
-static void tab_btnm_event_cb(lv_obj_t * tab_btnm, lv_event_t event);
-static void tabview_realign(lv_obj_t * tabview);
-static void refr_indic_size(lv_obj_t * tabview);
-static void refr_btns_size(lv_obj_t * tabview);
-static void refr_content_size(lv_obj_t * tabview);
-static void refr_align(lv_obj_t * tabview);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_signal_cb_t ancestor_scrl_signal;
-static lv_signal_cb_t page_signal;
-static const char * tab_def[] = {""};
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a Tab view object
- * @param par pointer to an object, it will be the parent of the new tab
- * @param copy pointer to a tab object, if not NULL then the new object will be copied from it
- * @return pointer to the created tab
- */
-lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("tab view create started");
-
-    /*Create the ancestor of tab*/
-    lv_obj_t * tabview = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(tabview);
-    if(tabview == NULL) return NULL;
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(tabview);
-
-    /*Allocate the tab type specific extended data*/
-    lv_tabview_ext_t * ext = lv_obj_allocate_ext_attr(tabview, sizeof(lv_tabview_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(tabview);
-        return NULL;
-    }
-
-    /*Initialize the allocated 'ext' */
-    ext->tab_cur      = 0;
-    ext->tab_cnt      = 0;
-    ext->point_last.x = 0;
-    ext->point_last.y = 0;
-    ext->content      = NULL;
-    ext->indic        = NULL;
-    ext->btns         = NULL;
-    ext->btns_pos     = LV_TABVIEW_TAB_POS_TOP;
-#if LV_USE_ANIMATION
-    ext->anim_time = LV_TABVIEW_DEF_ANIM_TIME;
-#endif
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(tabview, lv_tabview_signal);
-    /*Init the new tab tab*/
-    if(copy == NULL) {
-        ext->tab_name_ptr = lv_mem_alloc(sizeof(char *));
-        LV_ASSERT_MEM(ext->tab_name_ptr);
-        if(ext->tab_name_ptr == NULL) return NULL;
-        ext->tab_name_ptr[0] = "";
-
-        /* Set a size which fits into the parent.
-         * Don't use `par` directly because if the tabview is created on a page it is moved to the
-         * scrollable so the parent has changed */
-        lv_coord_t w;
-        lv_coord_t h;
-        if(par) {
-            w = lv_obj_get_width_fit(lv_obj_get_parent(tabview));
-            h = lv_obj_get_height_fit(lv_obj_get_parent(tabview));
-        }
-        else {
-            w = lv_disp_get_hor_res(NULL);
-            h = lv_disp_get_ver_res(NULL);
-        }
-
-        lv_obj_set_size(tabview, w, h);
-
-        ext->content = lv_page_create(tabview, NULL);
-        ext->btns    = lv_btnmatrix_create(tabview, NULL);
-        ext->indic   = lv_obj_create(ext->btns, NULL);
-
-        if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(ext->content));
-        lv_obj_set_signal_cb(lv_page_get_scrollable(ext->content), tabview_scrl_signal);
-
-        lv_btnmatrix_set_map(ext->btns, tab_def);
-        lv_obj_set_event_cb(ext->btns, tab_btnm_event_cb);
-
-        lv_obj_set_click(ext->indic, false);
-        lv_obj_set_drag_dir(lv_page_get_scrollable(ext->content), LV_DRAG_DIR_ONE);
-
-        lv_page_set_scrollable_fit2(ext->content, LV_FIT_TIGHT, LV_FIT_PARENT);
-        lv_page_set_scrl_layout(ext->content, LV_LAYOUT_ROW_TOP);
-        lv_page_set_scrollbar_mode(ext->content, LV_SCROLLBAR_MODE_OFF);
-
-        lv_obj_clean_style_list(ext->content, LV_PAGE_PART_BG);
-
-        lv_theme_apply(tabview, LV_THEME_TABVIEW);
-
-    }
-    /*Copy an existing tab view*/
-    else {
-        lv_tabview_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->point_last.x           = 0;
-        ext->point_last.y           = 0;
-        ext->btns                   = lv_btnmatrix_create(tabview, copy_ext->btns);
-        ext->indic                  = lv_obj_create(ext->btns, copy_ext->indic);
-        ext->content                = lv_page_create(tabview, copy_ext->content);
-#if LV_USE_ANIMATION
-        ext->anim_time = copy_ext->anim_time;
-#endif
-
-        ext->tab_name_ptr = lv_mem_alloc(sizeof(char *));
-        LV_ASSERT_MEM(ext->tab_name_ptr);
-        if(ext->tab_name_ptr == NULL) return NULL;
-        ext->tab_name_ptr[0] = "";
-        lv_btnmatrix_set_map(ext->btns, ext->tab_name_ptr);
-
-        lv_style_list_copy(lv_obj_get_style_list(tabview, LV_TABVIEW_PART_BG_SCRLLABLE), lv_obj_get_style_list(copy,
-                                                                                                               LV_TABVIEW_PART_BG_SCRLLABLE));
-        lv_style_list_copy(lv_obj_get_style_list(tabview, LV_TABVIEW_PART_TAB_BG), lv_obj_get_style_list(copy,
-                                                                                                         LV_TABVIEW_PART_TAB_BG));
-        lv_style_list_copy(lv_obj_get_style_list(tabview, LV_TABVIEW_PART_TAB_BTN), lv_obj_get_style_list(copy,
-                                                                                                          LV_TABVIEW_PART_TAB_BTN));
-
-        uint16_t i;
-        for(i = 0; i < copy_ext->tab_cnt; i++) {
-            lv_obj_t * new_tab = lv_tabview_add_tab(tabview, copy_ext->tab_name_ptr[i]);
-            lv_obj_t * copy_tab = lv_tabview_get_tab(copy, i);
-            lv_style_list_copy(lv_obj_get_style_list(new_tab, LV_PAGE_PART_SCROLLABLE), lv_obj_get_style_list(copy_tab,
-                                                                                                              LV_PAGE_PART_SCROLLABLE));
-            lv_style_list_copy(lv_obj_get_style_list(new_tab, LV_PAGE_PART_SCROLLBAR), lv_obj_get_style_list(copy_tab,
-                                                                                                             LV_PAGE_PART_SCROLLBAR));
-            lv_obj_refresh_style(new_tab, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-        }
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(tabview, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    tabview_realign(tabview);
-
-    LV_LOG_INFO("tab view created");
-
-    return tabview;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add a new tab with the given name
- * @param tabview pointer to Tab view object where to ass the new tab
- * @param name the text on the tab button
- * @return pointer to the created page object (lv_page). You can create your content here
- */
-lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-    LV_ASSERT_STR(name);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    /*Create the container page*/
-    lv_obj_t * h = lv_page_create(ext->content, NULL);
-    lv_obj_set_size(h, lv_obj_get_width(tabview), lv_obj_get_height(ext->content));
-    lv_page_set_scrollbar_mode(h, LV_SCROLLBAR_MODE_AUTO);
-    lv_page_set_scroll_propagation(h, true);
-    lv_page_set_scrollable_fit4(h, LV_FIT_NONE, LV_FIT_MAX, LV_FIT_NONE, LV_FIT_MAX);
-    lv_theme_apply(h, LV_THEME_TABVIEW_PAGE);
-
-    if(page_signal == NULL) page_signal = lv_obj_get_signal_cb(h);
-
-    /*Extend the button matrix map with the new name*/
-    char * name_dm;
-    name_dm = lv_mem_alloc(strlen(name) + 1); /*+1 for the the closing '\0' */
-    LV_ASSERT_MEM(name_dm);
-    if(name_dm == NULL) return NULL;
-    strcpy(name_dm, name);
-
-    ext->tab_cnt++;
-
-    /* FIXME: It is not possible yet to switch tab button position from/to top/bottom from/to left/right at runtime.
-     * Method: clean extra \n when switch from LV_TABVIEW_BTNS_POS_LEFT or LV_TABVIEW_BTNS_POS_RIGHT
-     * to LV_TABVIEW_BTNS_POS_TOP or LV_TABVIEW_BTNS_POS_BOTTOM.
-     */
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            ext->tab_name_ptr = lv_mem_realloc(ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt + 1));
-
-            LV_ASSERT_MEM(ext->tab_name_ptr);
-            if(ext->tab_name_ptr == NULL) return NULL;
-
-            ext->tab_name_ptr[ext->tab_cnt - 1] = name_dm;
-            ext->tab_name_ptr[ext->tab_cnt]     = "";
-
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            ext->tab_name_ptr = lv_mem_realloc(ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt * 2));
-
-            LV_ASSERT_MEM(ext->tab_name_ptr);
-            if(ext->tab_name_ptr == NULL) return NULL;
-
-            if(ext->tab_cnt == 1) {
-                ext->tab_name_ptr[0] = name_dm;
-                ext->tab_name_ptr[1] = "";
-            }
-            else {
-                ext->tab_name_ptr[ext->tab_cnt * 2 - 3] = "\n";
-                ext->tab_name_ptr[ext->tab_cnt * 2 - 2] = name_dm;
-                ext->tab_name_ptr[ext->tab_cnt * 2 - 1] = "";
-            }
-            break;
-    }
-
-    /* The button matrix's map still points to the old `tab_name_ptr` which might be freed by
-     * `lv_mem_realloc`. So make its current map invalid*/
-    lv_btnmatrix_ext_t * btnm_ext = lv_obj_get_ext_attr(ext->btns);
-    btnm_ext->map_p          = NULL;
-
-    lv_btnmatrix_set_map(ext->btns, ext->tab_name_ptr);
-    lv_btnmatrix_set_btn_ctrl(ext->btns, ext->tab_cur, LV_BTNMATRIX_CTRL_NO_REPEAT);
-
-    /*Set the first btn as active*/
-    if(ext->tab_cnt == 1)  ext->tab_cur = 0;
-
-    tabview_realign(tabview); /*Set the size of the pages, tab buttons and indicator*/
-
-    lv_tabview_set_tab_act(tabview, ext->tab_cur, false);
-
-    return h;
-}
-
-/**
- * Delete all children of a tab created by `lv_tabview_add_tab`.
- * @param tab pointer to a tab
- */
-void lv_tabview_clean_tab(lv_obj_t * tab)
-{
-    LV_ASSERT_OBJ(tab, "lv_page");
-
-    lv_obj_t * scrl = lv_page_get_scrollable(tab);
-    lv_obj_clean(scrl);
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new tab
- * @param tabview pointer to Tab view object
- * @param id index of a tab to load
- * @param anim LV_ANIM_ON: set the value with an animation; LV_ANIM_OFF: change the value immediately
- */
-void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t anim)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION == 0
-    anim = LV_ANIM_OFF;
-#endif
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    if(id >= ext->tab_cnt) id = ext->tab_cnt - 1;
-
-    lv_btnmatrix_clear_btn_ctrl(ext->btns, ext->tab_cur, LV_BTNMATRIX_CTRL_CHECK_STATE);
-
-    ext->tab_cur = id;
-
-    if(lv_obj_get_base_dir(tabview) == LV_BIDI_DIR_RTL) {
-        id = (ext->tab_cnt - (id + 1));
-    }
-
-    lv_coord_t cont_x;
-    lv_style_int_t scrl_inner = lv_obj_get_style_pad_inner(ext->content, LV_PAGE_PART_SCROLLABLE);
-    lv_style_int_t scrl_left = lv_obj_get_style_pad_left(ext->content, LV_PAGE_PART_SCROLLABLE);
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            cont_x = -(lv_obj_get_width(tabview) * id + scrl_inner * id + scrl_left);
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            cont_x = -((lv_obj_get_width(tabview) - lv_obj_get_width(ext->btns)) * id + scrl_inner * id + scrl_left);
-            break;
-    }
-
-    if(anim == LV_ANIM_OFF || lv_tabview_get_anim_time(tabview) == 0) {
-        lv_obj_set_x(lv_page_get_scrollable(ext->content), cont_x);
-    }
-#if LV_USE_ANIMATION
-    else {
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, lv_page_get_scrollable(ext->content));
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_x);
-        lv_anim_set_values(&a, lv_obj_get_x(lv_page_get_scrollable(ext->content)), cont_x);
-        lv_anim_set_time(&a, ext->anim_time);
-        lv_anim_start(&a);
-    }
-#endif
-
-    /*Move the indicator*/
-    lv_coord_t indic_size;
-    lv_coord_t indic_pos = 0; /*silence uninitialized variable warning*/;
-
-    lv_style_int_t btns_bg_inner = 0;
-    lv_style_int_t btns_bg_left = 0;
-    lv_style_int_t btns_bg_top = 0;
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-            break;
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            btns_bg_inner = lv_obj_get_style_pad_inner(tabview, LV_TABVIEW_PART_TAB_BG);
-            btns_bg_left = lv_obj_get_style_pad_left(tabview, LV_TABVIEW_PART_TAB_BG);
-            indic_size = lv_obj_get_width(ext->indic);
-            indic_pos  = indic_size * id + btns_bg_inner * id + btns_bg_left;
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            btns_bg_inner = lv_obj_get_style_pad_inner(tabview, LV_TABVIEW_PART_TAB_BG);
-            btns_bg_top = lv_obj_get_style_pad_top(tabview, LV_TABVIEW_PART_TAB_BG);
-            indic_size = lv_obj_get_height(ext->indic);
-            indic_pos  = btns_bg_top + id * (indic_size + btns_bg_inner);
-            break;
-    }
-
-#if LV_USE_ANIMATION
-    if(anim == LV_ANIM_OFF || ext->anim_time == 0)
-#endif
-    {
-        switch(ext->btns_pos) {
-            default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-            case LV_TABVIEW_TAB_POS_NONE:
-                break;
-            case LV_TABVIEW_TAB_POS_TOP:
-            case LV_TABVIEW_TAB_POS_BOTTOM:
-                lv_obj_set_x(ext->indic, indic_pos);
-                break;
-            case LV_TABVIEW_TAB_POS_LEFT:
-            case LV_TABVIEW_TAB_POS_RIGHT:
-                lv_obj_set_y(ext->indic, indic_pos);
-                break;
-        }
-    }
-#if LV_USE_ANIMATION
-    else {
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, ext->indic);
-        lv_anim_set_time(&a, ext->anim_time);
-
-        switch(ext->btns_pos) {
-            default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-            case LV_TABVIEW_TAB_POS_NONE:
-                break;
-            case LV_TABVIEW_TAB_POS_TOP:
-            case LV_TABVIEW_TAB_POS_BOTTOM:
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_x);
-                lv_anim_set_values(&a, lv_obj_get_x(ext->indic), indic_pos);
-                break;
-            case LV_TABVIEW_TAB_POS_LEFT:
-            case LV_TABVIEW_TAB_POS_RIGHT:
-                lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-                lv_anim_set_values(&a, lv_obj_get_y(ext->indic), indic_pos);
-                break;
-        }
-
-        lv_anim_start(&a);
-    }
-#endif
-
-    lv_btnmatrix_set_btn_ctrl(ext->btns, ext->tab_cur, LV_BTNMATRIX_CTRL_CHECK_STATE);
-}
-
-/**
- * Set the name of a tab.
- * @param tabview pointer to Tab view object
- * @param id index of the tab the name should be set
- * @param name new tab name
- */
-void lv_tabview_set_tab_name(lv_obj_t * tabview, uint16_t id, char * name)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    /* get tabview's ext pointer which contains the tab name pointer list */
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    /* check for valid tab index */
-    if(ext->tab_cnt > id) {
-        /* reallocate memory for new tab name (use reallocate due to mostly the size didn't change much) */
-        char * str = lv_mem_realloc((void *)ext->tab_name_ptr[id], strlen(name) + 1);
-        LV_ASSERT_MEM(str);
-
-        /* store new tab name at allocated memory */
-        strcpy(str, name);
-        /* update pointer  */
-        ext->tab_name_ptr[id] = str;
-
-        /* force redrawing of the tab headers */
-        lv_obj_invalidate(ext->btns);
-    }
-}
-
-/**
- * Set the animation time of tab view when a new tab is loaded
- * @param tabview pointer to Tab view object
- * @param anim_time_ms time of animation in milliseconds
- */
-void lv_tabview_set_anim_time(lv_obj_t * tabview, uint16_t anim_time)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    ext->anim_time         = anim_time;
-#else
-    (void)tabview;
-    (void)anim_time;
-#endif
-}
-
-/**
- * Set the position of tab select buttons
- * @param tabview pointer to a tan view object
- * @param btns_pos which button position
- */
-void lv_tabview_set_btns_pos(lv_obj_t * tabview, lv_tabview_btns_pos_t btns_pos)
-{
-    if(btns_pos != LV_TABVIEW_TAB_POS_NONE &&
-       btns_pos != LV_TABVIEW_TAB_POS_TOP &&
-       btns_pos != LV_TABVIEW_TAB_POS_BOTTOM &&
-       btns_pos != LV_TABVIEW_TAB_POS_LEFT &&
-       btns_pos != LV_TABVIEW_TAB_POS_RIGHT) {
-        LV_LOG_WARN("lv_tabview_set_btns_pos: unexpected button position");
-        return;
-    }
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    ext->btns_pos = btns_pos;
-    tabview_realign(tabview);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the index of the currently active tab
- * @param tabview pointer to Tab view object
- * @return the active btn index
- */
-uint16_t lv_tabview_get_tab_act(const lv_obj_t * tabview)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    return ext->tab_cur;
-}
-
-/**
- * Get the number of tabs
- * @param tabview pointer to Tab view object
- * @return btn count
- */
-uint16_t lv_tabview_get_tab_count(const lv_obj_t * tabview)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    return ext->tab_cnt;
-}
-
-/**
- * Get the page (content area) of a tab
- * @param tabview pointer to Tab view object
- * @param id index of the btn (>= 0)
- * @return pointer to page (lv_page) object
- */
-lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    lv_obj_t * content_scrl = lv_page_get_scrollable(ext->content);
-    uint16_t i             = 0;
-    lv_obj_t * page        = lv_obj_get_child_back(content_scrl, NULL);
-
-    while(page != NULL && i != id) {
-        if(lv_obj_get_signal_cb(page) == page_signal) i++;
-        page = lv_obj_get_child_back(content_scrl, page);
-    }
-
-    if(i == id) return page;
-
-    return NULL;
-}
-
-/**
- * Get the animation time of tab view when a new tab is loaded
- * @param tabview pointer to Tab view object
- * @return time of animation in milliseconds
- */
-uint16_t lv_tabview_get_anim_time(const lv_obj_t * tabview)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    return ext->anim_time;
-#else
-    (void)tabview;
-    return 0;
-#endif
-}
-
-/**
- * Get position of tab select buttons
- * @param tabview pointer to a ab view object
- */
-lv_tabview_btns_pos_t lv_tabview_get_btns_pos(const lv_obj_t * tabview)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    return ext->btns_pos;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the Tab view
- * @param tabview pointer to a Tab view object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_tabview_get_style(tabview, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(tabview, sign, param);
-    }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-        lv_get_state_info_t * info = param;
-        if(info->part == LV_TABVIEW_PART_TAB_BG) info->result = lv_obj_get_state(ext->btns, LV_BTNMATRIX_PART_BG);
-        else if(info->part == LV_TABVIEW_PART_TAB_BTN) info->result = lv_obj_get_state(ext->btns, LV_BTNMATRIX_PART_BTN);
-        else if(info->part == LV_TABVIEW_PART_INDIC) info->result = lv_obj_get_state(ext->indic, LV_OBJ_PART_MAIN);
-        else if(info->part == LV_TABVIEW_PART_BG_SCRLLABLE) info->result = lv_obj_get_state(ext->content,
-                                                                                                LV_PAGE_PART_SCROLLABLE);
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(tabview, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    if(sign == LV_SIGNAL_CLEANUP) {
-        uint8_t i;
-        for(i = 0; ext->tab_name_ptr[i][0] != '\0' && ext->tab_name_ptr[i][0] != '\n'; i++) lv_mem_free(ext->tab_name_ptr[i]);
-
-        lv_mem_free(ext->tab_name_ptr);
-        ext->tab_name_ptr = NULL;
-        ext->btns         = NULL; /*These objects were children so they are already invalid*/
-        ext->content      = NULL;
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        /*Be sure the buttons are updated because correct button size is required in `tabview_realign`*/
-        lv_signal_send(ext->btns, LV_SIGNAL_STYLE_CHG, NULL);
-
-        tabview_realign(tabview);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(ext->content != NULL && (lv_obj_get_width(tabview) != lv_area_get_width(param) ||
-                                    lv_obj_get_height(tabview) != lv_area_get_height(param))) {
-            tabview_realign(tabview);
-        }
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-#if LV_USE_GROUP
-        /*If released by a KEYPAD or ENCODER then really the tab buttons should be released.
-         * So simulate a CLICK on the tab buttons*/
-        lv_indev_t * indev         = lv_indev_get_act();
-        lv_indev_type_t indev_type = lv_indev_get_type(indev);
-        if(indev_type == LV_INDEV_TYPE_KEYPAD ||
-           (indev_type == LV_INDEV_TYPE_ENCODER && lv_group_get_editing(lv_obj_get_group(tabview)))) {
-            lv_event_send(ext->btns, LV_EVENT_CLICKED, lv_event_get_data());
-        }
-#endif
-    }
-    else if(sign == LV_SIGNAL_GET_EDITABLE) {
-#if LV_USE_GROUP
-        bool * editable = (bool *)param;
-        *editable       = true;
-#endif
-    }
-
-    if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS ||
-#if LV_USE_GROUP
-       sign == LV_SIGNAL_CONTROL ||
-#endif
-       sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_RELEASED) {
-
-        /* The button matrix is not in a group (the tab view is in it) but it should handle the
-         * group signals. So propagate the related signals to the button matrix manually*/
-        ext->btns->signal_cb(ext->btns, sign, param);
-
-        /*Make the active tab's button focused*/
-        if(sign == LV_SIGNAL_FOCUS) {
-            lv_btnmatrix_set_focused_btn(ext->btns, ext->tab_cur);
-        }
-
-        if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS) {
-            lv_state_t state = lv_obj_get_state(tabview, LV_TABVIEW_PART_BG);
-            if(state & LV_STATE_FOCUSED) {
-                lv_obj_set_state(ext->btns, LV_STATE_FOCUSED);
-                lv_obj_set_state(ext->indic, LV_STATE_FOCUSED);
-            }
-            else {
-                lv_obj_clear_state(ext->btns, LV_STATE_FOCUSED);
-                lv_obj_clear_state(ext->indic, LV_STATE_FOCUSED);
-
-            }
-            if(state & LV_STATE_EDITED) {
-                lv_obj_set_state(ext->btns, LV_STATE_EDITED);
-                lv_obj_set_state(ext->indic, LV_STATE_EDITED);
-            }
-            else {
-                lv_obj_clear_state(ext->btns, LV_STATE_EDITED);
-                lv_obj_clear_state(ext->indic, LV_STATE_EDITED);
-
-            }
-        }
-    }
-
-    return res;
-}
-
-/**
- * Signal function of a tab views main scrollable area
- * @param tab pointer to a tab page object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t tabview_scrl_signal(lv_obj_t * tabview_scrl, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_scrl_signal(tabview_scrl, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    lv_obj_t * cont    = lv_obj_get_parent(tabview_scrl);
-    lv_obj_t * tabview = lv_obj_get_parent(cont);
-
-    if(sign == LV_SIGNAL_DRAG_THROW_BEGIN) {
-        lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-        lv_indev_t * indev = lv_indev_get_act();
-        lv_point_t point_act;
-        lv_indev_get_point(indev, &point_act);
-        lv_point_t vect;
-        lv_indev_get_vect(indev, &vect);
-        lv_coord_t x_predict = 0;
-
-        while(vect.x != 0) {
-            x_predict += vect.x;
-            vect.x = vect.x * (100 - LV_INDEV_DEF_DRAG_THROW) / 100;
-        }
-
-        res = lv_indev_finish_drag(indev);
-        if(res != LV_RES_OK) return res;
-        lv_obj_t * tab_page = lv_tabview_get_tab(tabview, ext->tab_cur);
-        if(tab_page == NULL) return LV_RES_OK;
-        lv_coord_t page_x1  = tab_page->coords.x1 - tabview->coords.x1 + x_predict;
-        lv_coord_t page_x2  = page_x1 + lv_obj_get_width(tabview);
-        lv_coord_t treshold = lv_obj_get_width(tabview) / 2;
-
-        lv_bidi_dir_t base_dir = lv_obj_get_base_dir(tabview);
-        int16_t tab_cur = ext->tab_cur;
-        if(page_x1 > treshold) {
-            if(base_dir != LV_BIDI_DIR_RTL) tab_cur--;
-            else tab_cur ++;
-        }
-        else if(page_x2 < treshold) {
-            if(base_dir != LV_BIDI_DIR_RTL) tab_cur++;
-            else tab_cur --;
-        }
-
-        if(tab_cur > ext->tab_cnt - 1) tab_cur = ext->tab_cnt - 1;
-        if(tab_cur < 0) tab_cur = 0;
-
-        uint32_t id_prev = lv_tabview_get_tab_act(tabview);
-        lv_tabview_set_tab_act(tabview, tab_cur, LV_ANIM_ON);
-        uint32_t id_new = lv_tabview_get_tab_act(tabview);
-
-        if(id_prev != id_new) res = lv_event_send(tabview, LV_EVENT_VALUE_CHANGED, &id_prev);
-        if(res != LV_RES_OK) return res;
-
-    }
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param page pointer the object
- * @param part the part from `lv_tabview_part_t`. (LV_TABVIEW_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_tabview_get_style(lv_obj_t * tabview, uint8_t part)
-{
-    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
-
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_TABVIEW_PART_BG:
-            style_dsc_p = &tabview->style_list;
-            break;
-        case LV_TABVIEW_PART_BG_SCRLLABLE:
-            style_dsc_p = lv_obj_get_style_list(ext->content, LV_PAGE_PART_SCROLLABLE);
-            break;
-        case LV_TABVIEW_PART_TAB_BG:
-            style_dsc_p = lv_obj_get_style_list(ext->btns, LV_BTNMATRIX_PART_BG);
-            break;
-        case LV_TABVIEW_PART_TAB_BTN:
-            style_dsc_p = lv_obj_get_style_list(ext->btns, LV_BTNMATRIX_PART_BTN);
-            break;
-        case LV_TABVIEW_PART_INDIC:
-            style_dsc_p = lv_obj_get_style_list(ext->indic, LV_OBJ_PART_MAIN);
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-
-/**
- * Called when a tab button is clicked
- * @param tab_btnm pointer to the tab's button matrix object
- * @param event type of the event
- */
-static void tab_btnm_event_cb(lv_obj_t * tab_btnm, lv_event_t event)
-{
-    if(event != LV_EVENT_CLICKED) return;
-
-    uint16_t btn_id = lv_btnmatrix_get_active_btn(tab_btnm);
-    if(btn_id == LV_BTNMATRIX_BTN_NONE) return;
-
-    if(lv_btnmatrix_get_btn_ctrl(tab_btnm, btn_id, LV_BTNMATRIX_CTRL_DISABLED)) return;
-
-    lv_btnmatrix_clear_btn_ctrl_all(tab_btnm, LV_BTNMATRIX_CTRL_CHECK_STATE);
-    lv_btnmatrix_set_btn_ctrl(tab_btnm, btn_id, LV_BTNMATRIX_CTRL_CHECK_STATE);
-
-    lv_obj_t * tabview = lv_obj_get_parent(tab_btnm);
-
-    uint32_t id_prev = lv_tabview_get_tab_act(tabview);
-    lv_tabview_set_tab_act(tabview, btn_id, LV_ANIM_ON);
-    uint32_t id_new = lv_tabview_get_tab_act(tabview);
-
-    lv_res_t res = LV_RES_OK;
-    if(id_prev != id_new) res = lv_event_send(tabview, LV_EVENT_VALUE_CHANGED, &id_new);
-
-#if LV_USE_GROUP
-    if(lv_indev_get_type(lv_indev_get_act()) == LV_INDEV_TYPE_ENCODER) {
-        lv_group_set_editing(lv_obj_get_group(tabview), false);
-    }
-#endif
-
-    if(res != LV_RES_OK) return;
-}
-
-/**
- * Realign and resize the elements of Tab view
- * @param tabview pointer to a Tab view object
- */
-static void tabview_realign(lv_obj_t * tabview)
-{
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    refr_btns_size(tabview);
-    refr_content_size(tabview);
-    refr_indic_size(tabview);
-
-    refr_align(tabview);
-
-    lv_tabview_set_tab_act(tabview, ext->tab_cur, LV_ANIM_OFF);
-}
-
-static void refr_indic_size(lv_obj_t * tabview)
-{
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    lv_btnmatrix_ext_t * btnm_ext = lv_obj_get_ext_attr(ext->btns);
-
-    lv_coord_t indic_size = lv_obj_get_style_size(tabview, LV_TABVIEW_PART_INDIC);
-
-    /*Set the indicator width/height*/
-    lv_coord_t indic_w;
-    lv_coord_t indic_h;
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-            lv_obj_set_hidden(ext->indic, true);
-            indic_w = 0;
-            indic_h = 0;
-            break;
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            lv_obj_set_hidden(ext->indic, false);
-            if(ext->tab_cnt) {
-                indic_h = indic_size;
-                indic_w = lv_area_get_width(&btnm_ext->button_areas[0]);
-            }
-            else {
-                indic_w = 0;
-                indic_h = 0;
-            }
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            lv_obj_set_hidden(ext->indic, false);
-            if(ext->tab_cnt) {
-                indic_w = indic_size;
-                indic_h = lv_area_get_height(&btnm_ext->button_areas[0]);
-            }
-            else {
-                indic_w = 0;
-                indic_h = 0;
-            }
-            break;
-    }
-
-    lv_obj_set_width(ext->indic, indic_w);
-    lv_obj_set_height(ext->indic, indic_h);
-}
-
-
-static void refr_btns_size(lv_obj_t * tabview)
-{
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    lv_style_int_t tab_bg_left = lv_obj_get_style_pad_left(tabview, LV_TABVIEW_PART_TAB_BG);
-    lv_style_int_t tab_bg_right = lv_obj_get_style_pad_right(tabview, LV_TABVIEW_PART_TAB_BG);
-    lv_style_int_t tab_bg_top = lv_obj_get_style_pad_top(tabview, LV_TABVIEW_PART_TAB_BG);
-    lv_style_int_t tab_bg_bottom = lv_obj_get_style_pad_bottom(tabview, LV_TABVIEW_PART_TAB_BG);
-
-    lv_style_int_t tab_left = lv_obj_get_style_pad_left(tabview, LV_TABVIEW_PART_TAB_BTN);
-    lv_style_int_t tab_right = lv_obj_get_style_pad_right(tabview, LV_TABVIEW_PART_TAB_BTN);
-    lv_style_int_t tab_top = lv_obj_get_style_pad_top(tabview, LV_TABVIEW_PART_TAB_BTN);
-    lv_style_int_t tab_bottom = lv_obj_get_style_pad_bottom(tabview, LV_TABVIEW_PART_TAB_BTN);
-
-    const lv_font_t * font = lv_obj_get_style_text_font(tabview, LV_TABVIEW_PART_TAB_BTN);
-
-    /*Set the tabs height/width*/
-    lv_coord_t btns_w;
-    lv_coord_t btns_h;
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-            btns_w = 0;
-            btns_h = 0;
-            lv_obj_set_hidden(ext->btns, true);
-            break;
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            lv_obj_set_hidden(ext->btns, false);
-            btns_h = lv_font_get_line_height(font) + tab_top + tab_bottom + tab_bg_top + tab_bg_bottom;
-            btns_w = lv_obj_get_width(tabview);
-
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            lv_obj_set_hidden(ext->btns, false);
-            btns_w = lv_font_get_glyph_width(font, 'A', '\0') +
-                     tab_left + tab_right + tab_bg_left + tab_bg_right;
-            btns_h = lv_obj_get_height(tabview);
-            break;
-    }
-
-    lv_obj_set_size(ext->btns, btns_w, btns_h);
-}
-
-static void refr_content_size(lv_obj_t * tabview)
-{
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-    lv_coord_t cont_w;
-    lv_coord_t cont_h;
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-            cont_w = lv_obj_get_width(tabview);
-            cont_h = lv_obj_get_height(tabview);
-            break;
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            cont_w = lv_obj_get_width(tabview);
-            cont_h = lv_obj_get_height(tabview) - lv_obj_get_height(ext->btns);
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            cont_w = lv_obj_get_width(tabview) - lv_obj_get_width(ext->btns);
-            cont_h = lv_obj_get_height(tabview);
-            break;
-    }
-
-    lv_obj_set_size(ext->content, cont_w, cont_h);
-
-    /*Refresh the size of the tab pages too. `ext->content` has a layout to align the pages*/
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(tabview, LV_TABVIEW_PART_BG_SCRLLABLE);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(tabview, LV_TABVIEW_PART_BG_SCRLLABLE);
-    cont_h -= bg_top + bg_bottom;
-    lv_obj_t * content_scrl = lv_page_get_scrollable(ext->content);
-    lv_obj_t * pages = lv_obj_get_child(content_scrl, NULL);
-    while(pages != NULL) {
-        /*Be sure adjust only the pages (user can other things)*/
-        if(lv_obj_get_signal_cb(pages) == page_signal) {
-            lv_obj_set_size(pages, cont_w, cont_h);
-        }
-        pages = lv_obj_get_child(content_scrl, pages);
-    }
-}
-
-static void refr_align(lv_obj_t * tabview)
-{
-    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
-
-    switch(ext->btns_pos) {
-        default: /*default case is prevented in lv_tabview_set_btns_pos(), but here for safety*/
-        case LV_TABVIEW_TAB_POS_NONE:
-            lv_obj_align(ext->content, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            break;
-        case LV_TABVIEW_TAB_POS_TOP:
-            lv_obj_align(ext->btns, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            lv_obj_align(ext->content, ext->btns, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
-            lv_obj_align(ext->indic, ext->btns, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
-            break;
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            lv_obj_align(ext->content, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            lv_obj_align(ext->btns, ext->content, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
-            lv_obj_align(ext->indic, ext->btns, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-            lv_obj_align(ext->btns, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            lv_obj_align(ext->content, tabview, LV_ALIGN_IN_TOP_LEFT, lv_obj_get_width(ext->btns), 0);
-            lv_obj_align(ext->indic, ext->btns, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
-            break;
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            lv_obj_align(ext->btns, NULL, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
-            lv_obj_align(ext->content, tabview, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            lv_obj_align(ext->indic, ext->btns, LV_ALIGN_IN_TOP_LEFT, 0, 0);
-            break;
-    }
-}
-#endif
diff --git a/src/lv_widgets/lv_tabview.h b/src/lv_widgets/lv_tabview.h
deleted file mode 100644
index eca985e62..000000000
--- a/src/lv_widgets/lv_tabview.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/**
- * @file lv_tabview.h
- *
- */
-
-#ifndef LV_TABVIEW_H
-#define LV_TABVIEW_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_TABVIEW != 0
-
-/*Testing of dependencies*/
-#if LV_USE_BTNMATRIX == 0
-#error "lv_tabview: lv_btnm is required. Enable it in lv_conf.h (LV_USE_BTNMATRIX  1) "
-#endif
-
-#if LV_USE_PAGE == 0
-#error "lv_tabview: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "../lv_widgets/lv_win.h"
-#include "../lv_widgets/lv_page.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/** Position of tabview buttons. */
-enum {
-    LV_TABVIEW_TAB_POS_NONE,
-    LV_TABVIEW_TAB_POS_TOP,
-    LV_TABVIEW_TAB_POS_BOTTOM,
-    LV_TABVIEW_TAB_POS_LEFT,
-    LV_TABVIEW_TAB_POS_RIGHT
-};
-typedef uint8_t lv_tabview_btns_pos_t;
-
-/*Data of tab*/
-typedef struct {
-    /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * btns;
-    lv_obj_t * indic;
-    lv_obj_t * content; /*A background page which holds tab's pages*/
-    const char ** tab_name_ptr;
-    lv_point_t point_last;
-    uint16_t tab_cur;
-    uint16_t tab_cnt;
-#if LV_USE_ANIMATION
-    uint16_t anim_time;
-#endif
-    lv_tabview_btns_pos_t btns_pos : 3;
-} lv_tabview_ext_t;
-
-enum {
-    LV_TABVIEW_PART_BG = LV_OBJ_PART_MAIN,
-    _LV_TABVIEW_PART_VIRTUAL_LAST = _LV_OBJ_PART_VIRTUAL_LAST,
-
-    LV_TABVIEW_PART_BG_SCRLLABLE = _LV_OBJ_PART_REAL_LAST,
-    LV_TABVIEW_PART_TAB_BG,
-    LV_TABVIEW_PART_TAB_BTN,
-    LV_TABVIEW_PART_INDIC,
-    _LV_TABVIEW_PART_REAL_LAST,
-};
-typedef uint8_t lv_tabview_part_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a Tab view object
- * @param par pointer to an object, it will be the parent of the new tab
- * @param copy pointer to a tab object, if not NULL then the new object will be copied from it
- * @return pointer to the created tab
- */
-lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add a new tab with the given name
- * @param tabview pointer to Tab view object where to ass the new tab
- * @param name the text on the tab button
- * @return pointer to the created page object (lv_page). You can create your content here
- */
-lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name);
-
-/**
- * Delete all children of a tab created by `lv_tabview_add_tab`.
- * @param tab pointer to a tab
- */
-void lv_tabview_clean_tab(lv_obj_t * tab);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new tab
- * @param tabview pointer to Tab view object
- * @param id index of a tab to load
- * @param anim LV_ANIM_ON: set the value with an animation; LV_ANIM_OFF: change the value immediately
- */
-void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t anim);
-
-/**
- * Set the name of a tab.
- * @param tabview pointer to Tab view object
- * @param id index of the tab the name should be set
- * @param name new tab name
- */
-void lv_tabview_set_tab_name(lv_obj_t * tabview, uint16_t id, char * name);
-
-/**
- * Set the animation time of tab view when a new tab is loaded
- * @param tabview pointer to Tab view object
- * @param anim_time time of animation in milliseconds
- */
-void lv_tabview_set_anim_time(lv_obj_t * tabview, uint16_t anim_time);
-
-/**
- * Set the position of tab select buttons
- * @param tabview pointer to a tab view object
- * @param btns_pos which button position
- */
-void lv_tabview_set_btns_pos(lv_obj_t * tabview, lv_tabview_btns_pos_t btns_pos);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the index of the currently active tab
- * @param tabview pointer to Tab view object
- * @return the active tab index
- */
-uint16_t lv_tabview_get_tab_act(const lv_obj_t * tabview);
-
-/**
- * Get the number of tabs
- * @param tabview pointer to Tab view object
- * @return tab count
- */
-uint16_t lv_tabview_get_tab_count(const lv_obj_t * tabview);
-/**
- * Get the page (content area) of a tab
- * @param tabview pointer to Tab view object
- * @param id index of the tab (>= 0)
- * @return pointer to page (lv_page) object
- */
-lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id);
-
-/**
- * Get the animation time of tab view when a new tab is loaded
- * @param tabview pointer to Tab view object
- * @return time of animation in milliseconds
- */
-uint16_t lv_tabview_get_anim_time(const lv_obj_t * tabview);
-
-/**
- * Get position of tab select buttons
- * @param tabview pointer to a ab view object
- */
-lv_tabview_btns_pos_t lv_tabview_get_btns_pos(const lv_obj_t * tabview);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_TABVIEW*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_TABVIEW_H*/
diff --git a/src/lv_widgets/lv_tileview.c b/src/lv_widgets/lv_tileview.c
deleted file mode 100644
index 73014a7f5..000000000
--- a/src/lv_widgets/lv_tileview.c
+++ /dev/null
@@ -1,475 +0,0 @@
-/**
- * @file lv_tileview.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_tileview.h"
-#if LV_USE_TILEVIEW != 0
-
-#include <stdbool.h>
-#include "lv_cont.h"
-#include "../lv_misc/lv_math.h"
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_tileview"
-
-#if LV_USE_ANIMATION
-    #ifndef LV_TILEVIEW_DEF_ANIM_TIME
-        #define LV_TILEVIEW_DEF_ANIM_TIME 300 /*Animation time loading a tile [ms] (0: no animation)  */
-    #endif
-#else
-    #undef LV_TILEVIEW_DEF_ANIM_TIME
-    #define LV_TILEVIEW_DEF_ANIM_TIME 0 /*No animations*/
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_tileview_signal(lv_obj_t * tileview, lv_signal_t sign, void * param);
-static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
-static void drag_end_handler(lv_obj_t * tileview);
-static bool set_valid_drag_dirs(lv_obj_t * tileview);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_signal_cb_t ancestor_scrl_signal;
-static lv_design_cb_t ancestor_design;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a tileview object
- * @param par pointer to an object, it will be the parent of the new tileview
- * @param copy pointer to a tileview object, if not NULL then the new object will be copied from it
- * @return pointer to the created tileview
- */
-lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("tileview create started");
-
-    /*Create the ancestor of tileview*/
-    lv_obj_t * new_tileview = lv_page_create(par, copy);
-    LV_ASSERT_MEM(new_tileview);
-    if(new_tileview == NULL) return NULL;
-
-    /*Allocate the tileview type specific extended data*/
-    lv_tileview_ext_t * ext = lv_obj_allocate_ext_attr(new_tileview, sizeof(lv_tileview_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(new_tileview);
-        return NULL;
-    }
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(new_tileview);
-    if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(new_tileview));
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(new_tileview);
-
-    /*Initialize the allocated 'ext' */
-#if LV_USE_ANIMATION
-    ext->anim_time = LV_TILEVIEW_DEF_ANIM_TIME;
-#endif
-    ext->act_id.x      = 0;
-    ext->act_id.y      = 0;
-    ext->valid_pos     = NULL;
-    ext->valid_pos_cnt = 0;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(new_tileview, lv_tileview_signal);
-    lv_obj_set_signal_cb(lv_page_get_scrollable(new_tileview), lv_tileview_scrl_signal);
-
-    /*Init the new tileview*/
-    if(copy == NULL) {
-        /* Set a size which fits into the parent.
-         * Don't use `par` directly because if the tileview is created on a page it is moved to the
-         * scrollable so the parent has changed */
-        lv_coord_t w;
-        lv_coord_t h;
-        if(par) {
-            w = lv_obj_get_width_fit(lv_obj_get_parent(new_tileview));
-            h = lv_obj_get_height_fit(lv_obj_get_parent(new_tileview));
-        }
-        else {
-            w = lv_disp_get_hor_res(NULL);
-            h = lv_disp_get_ver_res(NULL);
-        }
-
-        lv_obj_set_size(new_tileview, w, h);
-        lv_obj_set_drag_throw(lv_page_get_scrollable(new_tileview), true);
-        lv_obj_set_drag_dir(lv_page_get_scrollable(new_tileview), LV_DRAG_DIR_ONE);
-
-        lv_page_set_scrollable_fit(new_tileview, LV_FIT_MAX);
-
-        lv_obj_reset_style_list(new_tileview, LV_PAGE_PART_SCROLLABLE);
-        lv_theme_apply(new_tileview, LV_THEME_TILEVIEW);
-    }
-    /*Copy an existing tileview*/
-    else {
-        lv_tileview_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->act_id.x                = copy_ext->act_id.x;
-        ext->act_id.y                = copy_ext->act_id.y;
-        ext->valid_pos               = copy_ext->valid_pos;
-        ext->valid_pos_cnt           = copy_ext->valid_pos_cnt;
-#if LV_USE_ANIMATION
-        ext->anim_time = copy_ext->anim_time;
-#endif
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(new_tileview, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("tileview created");
-
-    return new_tileview;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Register an object on the tileview. The register object will able to slide the tileview
- * @param tileview pointer to a Tileview object
- * @param element pointer to an object
- */
-void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element)
-{
-    LV_UNUSED(tileview);
-    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
-    LV_ASSERT_NULL(tileview);
-
-    lv_page_glue_obj(tileview, element, true);
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the valid position's indices. The scrolling will be possible only to these positions.
- * @param tileview pointer to a Tileview object
- * @param valid_pos array width the indices. E.g. `lv_point_t p[] = {{0,0}, {1,0}, {1,1}`.
- * Only the pointer is saved so can't be a local variable.
- * @param valid_pos_cnt number of elements in `valid_pos` array
- */
-void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t valid_pos[], uint16_t valid_pos_cnt)
-{
-    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
-    LV_ASSERT_NULL(valid_pos);
-
-    lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-    ext->valid_pos          = valid_pos;
-    ext->valid_pos_cnt      = valid_pos_cnt;
-
-    set_valid_drag_dirs(tileview);
-
-    /*If valid pos. is selected do nothing*/
-    uint16_t i;
-    for(i = 0; i < valid_pos_cnt; i++) {
-        if(valid_pos[i].x == ext->act_id.x && valid_pos[i].y == ext->act_id.y) {
-            return;
-        }
-    }
-
-    /*Set a valid position if now an invalid is selected*/
-    if(valid_pos_cnt > 0) {
-        lv_tileview_set_tile_act(tileview, valid_pos[0].x, valid_pos[0].y, LV_ANIM_OFF);
-    }
-}
-
-/**
- * Set the tile to be shown
- * @param tileview pointer to a tileview object
- * @param x column id (0, 1, 2...)
- * @param y line id (0, 1, 2...)
- * @param anim LV_ANIM_ON: set the value with an animation; LV_ANIM_OFF: change the value immediately
- */
-void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim)
-{
-    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
-
-#if LV_USE_ANIMATION == 0
-    anim = LV_ANIM_OFF;
-#endif
-
-    lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-
-    uint32_t tile_id;
-    bool valid = false;
-    for(tile_id = 0; tile_id < ext->valid_pos_cnt; tile_id++) {
-        if(ext->valid_pos[tile_id].x == x && ext->valid_pos[tile_id].y == y) {
-            valid = true;
-            break;
-        }
-    }
-
-    if(valid == false) return; /*Don't load not valid tiles*/
-
-    ext->act_id.x = x;
-    ext->act_id.y = y;
-
-    lv_coord_t x_coord = -x * lv_obj_get_width(tileview);
-    lv_coord_t y_coord = -y * lv_obj_get_height(tileview);
-    lv_obj_t * scrl    = lv_page_get_scrollable(tileview);
-    if(anim) {
-#if LV_USE_ANIMATION
-        lv_coord_t x_act = lv_obj_get_x(scrl);
-        lv_coord_t y_act = lv_obj_get_y(scrl);
-
-        lv_anim_t a;
-        lv_anim_init(&a);
-        lv_anim_set_var(&a, scrl);
-        lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_x);
-        lv_anim_set_time(&a, ext->anim_time);
-
-
-        if(x_coord != x_act) {
-            lv_anim_set_values(&a, x_act, x_coord);
-            lv_anim_start(&a);
-        }
-
-        if(y_coord != y_act) {
-            lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-            lv_anim_set_values(&a, y_act, y_coord);
-            lv_anim_start(&a);
-        }
-#endif
-    }
-    else {
-        lv_obj_set_pos(scrl, x_coord, y_coord);
-    }
-
-    lv_res_t res;
-    res          = lv_event_send(tileview, LV_EVENT_VALUE_CHANGED, &tile_id);
-    if(res != LV_RES_OK) return; /*Prevent the tile loading*/
-
-    set_valid_drag_dirs(tileview);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/*
- * New object specific "get" functions come here
- */
-/**
-* Get the tile to be shown
-* @param tileview pointer to a tileview object
-* @param x column id (0, 1, 2...)
-* @param y line id (0, 1, 2...)
-*/
-void lv_tileview_get_tile_act(lv_obj_t * tileview, lv_coord_t * x, lv_coord_t * y)
-{
-    lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-
-    *x = ext->act_id.x;
-    *y = ext->act_id.y;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/*
- * New object specific "other" functions come here
- */
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the tileview
- * @param tileview pointer to a tileview object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_tileview_signal(lv_obj_t * tileview, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(tileview, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    }
-
-    return res;
-}
-
-/**
- * Signal function of the tileview scrollable
- * @param tileview pointer to the scrollable part of the tileview object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
-{
-
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_scrl_signal(scrl, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    lv_obj_t * tileview         = lv_obj_get_parent(scrl);
-
-    if(sign == LV_SIGNAL_DRAG_BEGIN) {
-        set_valid_drag_dirs(tileview);
-    }
-    else if(sign == LV_SIGNAL_DRAG_THROW_BEGIN) {
-        drag_end_handler(tileview);
-
-        res = lv_indev_finish_drag(lv_indev_get_act());
-        if(res != LV_RES_OK) return res;
-    }
-    /*Apply constraint on moving of the tileview*/
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        lv_indev_t * indev = lv_indev_get_act();
-        if(indev) {
-            lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-
-            lv_coord_t x = lv_obj_get_x(scrl);
-            lv_coord_t y = lv_obj_get_y(scrl);
-            lv_coord_t h = lv_obj_get_height(tileview);
-            lv_coord_t w = lv_obj_get_width(tileview);
-            lv_coord_t top = lv_obj_get_style_pad_top(tileview, LV_TILEVIEW_PART_BG);
-            lv_coord_t left = lv_obj_get_style_pad_left(tileview, LV_TILEVIEW_PART_BG);
-            if(!ext->drag_top_en && y > -(ext->act_id.y * h) && indev->proc.types.pointer.vect.y > 0)  {
-                lv_page_start_edge_flash(tileview, LV_PAGE_EDGE_TOP);
-                lv_obj_set_y(scrl, -ext->act_id.y * h + top);
-            }
-            if(!ext->drag_bottom_en && indev->proc.types.pointer.vect.y < 0 && y < -(ext->act_id.y * h)) {
-                lv_page_start_edge_flash(tileview, LV_PAGE_EDGE_BOTTOM);
-                lv_obj_set_y(scrl, -ext->act_id.y * h + top);
-            }
-
-            if(!ext->drag_left_en && x > -(ext->act_id.x * w) && indev->proc.types.pointer.vect.x > 0) {
-                lv_page_start_edge_flash(tileview, LV_PAGE_EDGE_LEFT);
-                lv_obj_set_x(scrl, -ext->act_id.x * w + left);
-            }
-
-            if(!ext->drag_right_en && indev->proc.types.pointer.vect.x < 0 && x < -(ext->act_id.x * w)) {
-                lv_page_start_edge_flash(tileview, LV_PAGE_EDGE_RIGHT);
-                lv_obj_set_x(scrl, -ext->act_id.x * w + left);
-            }
-
-            /*Apply the drag constraints*/
-            lv_scroll_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
-            if(drag_dir == LV_DRAG_DIR_HOR)
-                lv_obj_set_y(scrl, -ext->act_id.y * lv_obj_get_height(tileview) + top);
-            else if(drag_dir == LV_DRAG_DIR_VER)
-                lv_obj_set_x(scrl, -ext->act_id.x * lv_obj_get_width(tileview) + left);
-        }
-    }
-    return res;
-}
-
-/**
- * Called when the user releases an element of the tileview after dragging it.
- * @param tileview pointer to a tileview object
- */
-static void drag_end_handler(lv_obj_t * tileview)
-{
-    lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-    lv_indev_t * indev      = lv_indev_get_act();
-    lv_point_t point_act;
-    lv_indev_get_point(indev, &point_act);
-    lv_obj_t * scrl = lv_page_get_scrollable(tileview);
-    lv_point_t p;
-
-    p.x = -(lv_obj_get_x(scrl) - lv_obj_get_width(tileview) / 2);
-    p.y = -(lv_obj_get_y(scrl) - lv_obj_get_height(tileview) / 2);
-
-    lv_scroll_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
-    /*From the drag vector (drag throw) predict the end position*/
-    if(drag_dir & LV_DRAG_DIR_HOR) {
-        lv_point_t vect;
-        lv_indev_get_vect(indev, &vect);
-        lv_coord_t predict = 0;
-
-        while(vect.x != 0) {
-            predict += vect.x;
-            vect.x = vect.x * (100 - LV_INDEV_DEF_DRAG_THROW) / 100;
-        }
-
-        p.x -= predict;
-
-    }
-    else if(drag_dir & LV_DRAG_DIR_VER) {
-        lv_point_t vect;
-        lv_indev_get_vect(indev, &vect);
-        lv_coord_t predict = 0;
-
-        while(vect.y != 0) {
-            predict += vect.y;
-            vect.y = vect.y * (100 - LV_INDEV_DEF_DRAG_THROW) / 100;
-        }
-
-        p.y -= predict;
-    }
-
-    /*Get the index of the tile*/
-    p.x = p.x / lv_obj_get_width(tileview);
-    p.y = p.y / lv_obj_get_height(tileview);
-
-    /*Max +- move*/
-    lv_coord_t x_move = p.x - ext->act_id.x;
-    lv_coord_t y_move = p.y - ext->act_id.y;
-    if(x_move < -1) x_move = -1;
-    if(x_move > 1) x_move = 1;
-    if(y_move < -1) y_move = -1;
-    if(y_move > 1) y_move = 1;
-
-    /*Set the new tile*/
-    lv_tileview_set_tile_act(tileview, ext->act_id.x + x_move, ext->act_id.y + y_move, true);
-}
-
-static bool set_valid_drag_dirs(lv_obj_t * tileview)
-{
-
-    lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
-    if(ext->valid_pos == NULL) return false;
-
-    ext->drag_bottom_en = 0;
-    ext->drag_top_en    = 0;
-    ext->drag_left_en   = 0;
-    ext->drag_right_en  = 0;
-
-    uint16_t i;
-    for(i = 0; i < ext->valid_pos_cnt; i++) {
-        if(ext->valid_pos[i].x == ext->act_id.x && ext->valid_pos[i].y == ext->act_id.y - 1) ext->drag_top_en = 1;
-        if(ext->valid_pos[i].x == ext->act_id.x && ext->valid_pos[i].y == ext->act_id.y + 1) ext->drag_bottom_en = 1;
-        if(ext->valid_pos[i].x == ext->act_id.x - 1 && ext->valid_pos[i].y == ext->act_id.y) ext->drag_left_en = 1;
-        if(ext->valid_pos[i].x == ext->act_id.x + 1 && ext->valid_pos[i].y == ext->act_id.y) ext->drag_right_en = 1;
-    }
-
-    return true;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_tileview.h b/src/lv_widgets/lv_tileview.h
deleted file mode 100644
index 984fc3950..000000000
--- a/src/lv_widgets/lv_tileview.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/**
- * @file lv_tileview.h
- *
- */
-
-#ifndef LV_TILEVIEW_H
-#define LV_TILEVIEW_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_TILEVIEW != 0
-
-#include "../lv_widgets/lv_page.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of tileview*/
-typedef struct {
-    lv_page_ext_t page;
-    /*New data for this type */
-    const lv_point_t * valid_pos;
-    uint16_t valid_pos_cnt;
-#if LV_USE_ANIMATION
-    uint16_t anim_time;
-#endif
-    lv_point_t act_id;
-    uint8_t drag_top_en : 1;
-    uint8_t drag_bottom_en : 1;
-    uint8_t drag_left_en : 1;
-    uint8_t drag_right_en : 1;
-} lv_tileview_ext_t;
-
-/*Parts of the Tileview*/
-enum {
-    LV_TILEVIEW_PART_BG = LV_PAGE_PART_BG,
-    LV_TILEVIEW_PART_SCROLLBAR = LV_PAGE_PART_SCROLLBAR,
-    LV_TILEVIEW_PART_EDGE_FLASH = LV_PAGE_PART_EDGE_FLASH,
-    _LV_TILEVIEW_PART_VIRTUAL_LAST = _LV_PAGE_PART_VIRTUAL_LAST,
-    _LV_TILEVIEW_PART_REAL_LAST = _LV_PAGE_PART_REAL_LAST
-};
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a tileview objects
- * @param par pointer to an object, it will be the parent of the new tileview
- * @param copy pointer to a tileview object, if not NULL then the new object will be copied from it
- * @return pointer to the created tileview
- */
-lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Register an object on the tileview. The register object will able to slide the tileview
- * @param tileview pointer to a Tileview object
- * @param element pointer to an object
- */
-void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the valid position's indices. The scrolling will be possible only to these positions.
- * @param tileview pointer to a Tileview object
- * @param valid_pos array width the indices. E.g. `lv_point_t p[] = {{0,0}, {1,0}, {1,1}`.
- *  Only the pointer is saved so can't be a local variable.
- * @param valid_pos_cnt number of elements in `valid_pos` array
- */
-void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t valid_pos[], uint16_t valid_pos_cnt);
-
-/**
- * Set the tile to be shown
- * @param tileview pointer to a tileview object
- * @param x column id (0, 1, 2...)
- * @param y line id (0, 1, 2...)
- * @param anim LV_ANIM_ON: set the value with an animation; LV_ANIM_OFF: change the value immediately
- */
-void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim);
-
-/**
- * Enable the edge flash effect. (Show an arc when the an edge is reached)
- * @param tileview pointer to a Tileview
- * @param en true or false to enable/disable end flash
- */
-static inline void lv_tileview_set_edge_flash(lv_obj_t * tileview, bool en)
-{
-    lv_page_set_edge_flash(tileview, en);
-}
-
-/**
- * Set the animation time for the Tile view
- * @param tileview pointer to a page object
- * @param anim_time animation time in milliseconds
- */
-static inline void lv_tileview_set_anim_time(lv_obj_t * tileview, uint16_t anim_time)
-{
-    lv_page_set_anim_time(tileview, anim_time);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-/**
-* Get the tile to be shown
-* @param tileview pointer to a tileview object
-* @param x column id (0, 1, 2...)
-* @param y line id (0, 1, 2...)
-*/
-void lv_tileview_get_tile_act(lv_obj_t * tileview, lv_coord_t * x, lv_coord_t * y);
-/**
- * Get the scroll propagation property
- * @param tileview pointer to a Tileview
- * @return true or false
- */
-static inline bool lv_tileview_get_edge_flash(lv_obj_t * tileview)
-{
-    return lv_page_get_edge_flash(tileview);
-}
-
-/**
- * Get the animation time for the Tile view
- * @param tileview pointer to a page object
- * @return animation time in milliseconds
- */
-static inline uint16_t lv_tileview_get_anim_time(lv_obj_t * tileview)
-{
-    return lv_page_get_anim_time(tileview);
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_TILEVIEW*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_TILEVIEW_H*/
diff --git a/src/lv_widgets/lv_win.c b/src/lv_widgets/lv_win.c
deleted file mode 100644
index 0e122976d..000000000
--- a/src/lv_widgets/lv_win.c
+++ /dev/null
@@ -1,807 +0,0 @@
-/**
- * @file lv_win.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_win.h"
-#if LV_USE_WIN != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_core/lv_disp.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_win"
-#define DEF_TITLE "Window"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/** Extended data of win_btn*/
-typedef struct {
-    /** Ext. of ancestor*/
-    lv_btn_ext_t btn;
-
-    /** Which side of the header should the button be aligned to.
-     * 0: Align to right (default), 1: Align to left */
-    uint8_t alignment_in_header : 1;
-} lv_win_btn_ext_t;
-
-enum {
-    LV_WIN_BTN_ALIGN_RIGHT = 0,     /**< Align button to right of the header */
-    LV_WIN_BTN_ALIGN_LEFT   /**< Align button to left of the header */
-};
-typedef uint8_t lv_win_btn_align_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param);
-static lv_design_res_t lv_win_header_design(lv_obj_t * header, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_style_list_t * lv_win_get_style(lv_obj_t * win, uint8_t part);
-static void lv_win_realign(lv_obj_t * win);
-static lv_obj_t * lv_win_btn_create(lv_obj_t * par, const void * img_src);
-static void lv_win_btn_set_alignment(lv_obj_t * par, const lv_win_btn_align_t alignment);
-static lv_win_btn_align_t lv_win_btn_get_alignment(const lv_obj_t * par);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_cb_t ancestor_header_design;
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a window objects
- * @param par pointer to an object, it will be the parent of the new window
- * @param copy pointer to a window object, if not NULL then the new object will be copied from it
- * @return pointer to the created window
- */
-lv_obj_t * lv_win_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("window create started");
-
-    /*Create the ancestor object*/
-    lv_obj_t * new_win = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(new_win);
-    if(new_win == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(new_win);
-
-    /*Allocate the object type specific extended data*/
-    lv_win_ext_t * ext = lv_obj_allocate_ext_attr(new_win, sizeof(lv_win_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(new_win);
-        return NULL;
-    }
-
-    ext->page          = NULL;
-    ext->header        = NULL;
-    ext->title_txt    = lv_mem_alloc(strlen(DEF_TITLE) + 1);
-    strcpy(ext->title_txt, DEF_TITLE);
-
-    /*Init the new window object*/
-    if(copy == NULL) {
-        /* Set a size which fits into the parent.
-         * Don't use `par` directly because if the window is created on a page it is moved to the
-         * scrollable so the parent has changed */
-        lv_coord_t w;
-        lv_coord_t h;
-        if(par) {
-            w = lv_obj_get_width_fit(lv_obj_get_parent(new_win));
-            h = lv_obj_get_height_fit(lv_obj_get_parent(new_win));
-        }
-        else {
-            w = lv_disp_get_hor_res(NULL);
-            h = lv_disp_get_ver_res(NULL);
-        }
-
-        lv_obj_set_size(new_win, w, h);
-
-        ext->btn_w = LV_DPX(65);
-
-        ext->page = lv_page_create(new_win, NULL);
-        lv_obj_add_protect(ext->page, LV_PROTECT_PARENT);
-        lv_page_set_scrollbar_mode(ext->page, LV_SCROLLBAR_MODE_AUTO);
-        lv_obj_clean_style_list(ext->page, LV_PAGE_PART_BG);
-
-        /*Create a holder for the header*/
-        ext->header = lv_obj_create(new_win, NULL);
-        /*Move back to window background because it's automatically moved to the content page*/
-        lv_obj_add_protect(ext->header, LV_PROTECT_PARENT);
-        lv_obj_set_parent(ext->header, new_win);
-        if(ancestor_header_design == NULL) ancestor_header_design = lv_obj_get_design_cb(ext->header);
-        lv_obj_set_height(ext->header, LV_DPX(65));
-
-        lv_obj_set_design_cb(ext->header, lv_win_header_design);
-        lv_obj_set_signal_cb(new_win, lv_win_signal);
-
-        lv_theme_apply(new_win, LV_THEME_WIN);
-    }
-    /*Copy an existing object*/
-    else {
-        lv_win_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        /*Create the objects*/
-        ext->header   = lv_obj_create(new_win, copy_ext->header);
-        ext->title_txt    = lv_mem_alloc(strlen(copy_ext->title_txt) + 1);
-        strcpy(ext->title_txt, copy_ext->title_txt);
-        ext->page     = lv_page_create(new_win, copy_ext->page);
-        ext->btn_w     = copy_ext->btn_w;
-
-        /*Copy the buttons*/
-        lv_obj_t * child;
-        child = lv_obj_get_child_back(copy_ext->header, NULL);
-        child = lv_obj_get_child_back(copy_ext->header, child); /*Sip the title*/
-        while(child != NULL) {
-            lv_obj_t * btn = lv_btn_create(ext->header, child);
-            lv_img_create(btn, lv_obj_get_child(child, NULL));
-            child = lv_obj_get_child_back(copy_ext->header, child);
-        }
-
-        lv_obj_set_signal_cb(new_win, lv_win_signal);
-    }
-
-    /*Refresh the style with new signal function*/
-    lv_obj_refresh_style(new_win, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-
-    lv_win_realign(new_win);
-
-    LV_LOG_INFO("window created");
-
-    return new_win;
-}
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param win pointer to an object
- */
-void lv_win_clean(lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_obj_t * scrl = lv_page_get_scrollable(win);
-    lv_obj_clean(scrl);
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add control button to the header of the window
- * @param win pointer to a window object
- * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
- * @param alignment button alignment on the header
- * @return pointer to the created button object
- */
-lv_obj_t * lv_win_add_btn_right(lv_obj_t * win, const void * img_src)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-    LV_ASSERT_NULL(img_src);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-    lv_obj_t * btn = lv_win_btn_create(ext->header, img_src);
-    lv_win_btn_set_alignment(btn, LV_WIN_BTN_ALIGN_RIGHT);
-
-    lv_win_realign(win);
-
-    return btn;
-}
-
-/**
- * Add control button on the left side of the window header
- * @param win pointer to a window object
- * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
- * @return pointer to the created button object
- */
-lv_obj_t * lv_win_add_btn_left(lv_obj_t * win, const void * img_src)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-    LV_ASSERT_NULL(img_src);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-    lv_obj_t * btn = lv_win_btn_create(ext->header, img_src);
-    lv_win_btn_set_alignment(btn, LV_WIN_BTN_ALIGN_LEFT);
-
-    lv_win_realign(win);
-
-    return btn;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Can be assigned to a window control button to close the window
- * @param btn pointer to the control button on the widows header
- * @param evet the event type
- */
-void lv_win_close_event_cb(lv_obj_t * btn, lv_event_t event)
-{
-    LV_ASSERT_OBJ(btn, "lv_btn");
-
-    if(event == LV_EVENT_RELEASED) {
-        lv_obj_t * win = lv_win_get_from_btn(btn);
-
-        lv_obj_del(win);
-    }
-}
-
-/**
- * Set the title of a window
- * @param win pointer to a window object
- * @param title string of the new title
- */
-void lv_win_set_title(lv_obj_t * win, const char * title)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-    LV_ASSERT_STR(title);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-    ext->title_txt    = lv_mem_realloc(ext->title_txt, strlen(title) + 1);
-    LV_ASSERT_MEM(ext->title_txt);
-    if(ext->title_txt == NULL) return;
-
-    strcpy(ext->title_txt, title);
-    lv_obj_invalidate(ext->header);
-}
-
-/**
- * Set the height of the header
- * @param win pointer to a window object
- * @param height height of the header
- */
-void lv_win_set_header_height(lv_obj_t * win, lv_coord_t height)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-    lv_obj_set_height(ext->header, height);
-    lv_win_realign(win);
-}
-
-/**
- * Set the width of the control buttons on the header
- * @param win pointer to a window object
- * @param width width of the control button. 0: to make them square automatically.
- */
-void lv_win_set_btn_width(lv_obj_t * win, lv_coord_t width)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    ext->btn_w = width;
-    lv_win_realign(win);
-}
-
-/**
- * Set the size of the content area.
- * It's the effective area where object can be placed.
- * @param win pointer to a window object
- * @param w width
- * @param h height (the window will be higher with the height of the header)
- */
-void lv_win_set_content_size(lv_obj_t * win, lv_coord_t w, lv_coord_t h)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    h += lv_obj_get_height(ext->header);
-
-    lv_obj_set_size(win, w, h);
-}
-
-/**
- * Set the layout of the window
- * @param win pointer to a window object
- * @param layout the layout from 'lv_layout_t'
- */
-void lv_win_set_layout(lv_obj_t * win, lv_layout_t layout)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    lv_page_set_scrl_layout(ext->page, layout);
-}
-
-/**
- * Set the scroll bar mode of a window
- * @param win pointer to a window object
- * @param sb_mode the new scroll bar mode from  'lv_sb_mode_t'
- */
-void lv_win_set_scrollbar_mode(lv_obj_t * win, lv_scrollbar_mode_t sb_mode)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    lv_page_set_scrollbar_mode(ext->page, sb_mode);
-}
-/**
- * Set focus animation duration on `lv_win_focus()`
- * @param win pointer to a window object
- * @param anim_time duration of animation [ms]
- */
-void lv_win_set_anim_time(lv_obj_t * win, uint16_t anim_time)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_page_set_anim_time(lv_win_get_content(win), anim_time);
-}
-
-/**
- * Set drag status of a window. If set to 'true' window can be dragged like on a PC.
- * @param win pointer to a window object
- * @param en whether dragging is enabled
- */
-void lv_win_set_drag(lv_obj_t * win, bool en)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext    = lv_obj_get_ext_attr(win);
-    lv_obj_t * win_header = ext->header;
-    lv_obj_set_drag_parent(win_header, en);
-    lv_obj_set_drag(win, en);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the title of a window
- * @param win pointer to a window object
- * @return title string of the window
- */
-const char * lv_win_get_title(const lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return ext->title_txt;
-}
-
-/**
- * Get the content holder object of window (`lv_page`) to allow additional customization
- * @param win pointer to a window object
- * @return the Page object where the window's content is
- */
-lv_obj_t * lv_win_get_content(const lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return ext->page;
-}
-
-/**
- * Get the header height
- * @param win pointer to a window object
- * @return header height
- */
-lv_coord_t lv_win_get_header_height(const lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return lv_obj_get_height(ext->header);
-}
-
-/**
- * Get the width of the control buttons on the header
- * @param win pointer to a window object
- * @return width of the control button. 0: square.
- */
-lv_coord_t lv_win_get_btn_width(lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return ext->btn_w;
-
-}
-
-/**
- * Get the pointer of a widow from one of  its control button.
- * It is useful in the action of the control buttons where only button is known.
- * @param ctrl_btn pointer to a control button of a window
- * @return pointer to the window of 'ctrl_btn'
- */
-lv_obj_t * lv_win_get_from_btn(const lv_obj_t * ctrl_btn)
-{
-    LV_ASSERT_OBJ(ctrl_btn, "lv_btn");
-
-    lv_obj_t * header = lv_obj_get_parent(ctrl_btn);
-    lv_obj_t * win    = lv_obj_get_parent(header);
-
-    return win;
-}
-
-/**
- * Get the layout of a window
- * @param win pointer to a window object
- * @return the layout of the window (from 'lv_layout_t')
- */
-lv_layout_t lv_win_get_layout(lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return lv_page_get_scrl_layout(ext->page);
-}
-
-/**
- * Get the scroll bar mode of a window
- * @param win pointer to a window object
- * @return the scroll bar mode of the window (from 'lv_sb_mode_t')
- */
-lv_scrollbar_mode_t lv_win_get_sb_mode(lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    return lv_page_get_scrollbar_mode(ext->page);
-}
-
-/**
- * Get focus animation duration
- * @param win pointer to a window object
- * @return duration of animation [ms]
- */
-uint16_t lv_win_get_anim_time(const lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    return lv_page_get_anim_time(lv_win_get_content(win));
-}
-
-/**
- * Get width of the content area (page scrollable) of the window
- * @param win pointer to a window object
- * @return the width of the content_bg area
- */
-lv_coord_t lv_win_get_width(lv_obj_t * win)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext            = lv_obj_get_ext_attr(win);
-    lv_obj_t * scrl               = lv_page_get_scrollable(ext->page);
-    lv_coord_t left = lv_obj_get_style_pad_left(win, LV_WIN_PART_BG);
-    lv_coord_t right = lv_obj_get_style_pad_left(win, LV_WIN_PART_BG);
-
-    return lv_obj_get_width_fit(scrl) - left - right;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Focus on an object. It ensures that the object will be visible in the window.
- * @param win pointer to a window object
- * @param obj pointer to an object to focus (must be in the window)
- * @param anim_en LV_ANIM_ON focus with an animation; LV_ANIM_OFF focus without animation
- */
-void lv_win_focus(lv_obj_t * win, lv_obj_t * obj, lv_anim_enable_t anim_en)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-    LV_ASSERT_OBJ(obj, "");
-
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    lv_page_focus(ext->page, obj, anim_en);
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-/**
- * Handle the drawing related tasks of the window header
- * @param header pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_win_header_design(lv_obj_t * header, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_header_design(header, clip_area, mode);
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_header_design(header, clip_area, mode);
-
-        lv_obj_t * win = lv_obj_get_parent(header);
-        lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-        lv_style_int_t header_left = lv_obj_get_style_pad_left(win, LV_WIN_PART_HEADER);
-        lv_style_int_t header_inner = lv_obj_get_style_pad_inner(win, LV_WIN_PART_HEADER);
-
-        lv_draw_label_dsc_t label_dsc;
-        lv_draw_label_dsc_init(&label_dsc);
-        lv_obj_init_draw_label_dsc(header, LV_OBJ_PART_MAIN, &label_dsc);
-
-        lv_area_t txt_area;
-        lv_point_t txt_size;
-
-        _lv_txt_get_size(&txt_size, ext->title_txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
-                         label_dsc.flag);
-
-        lv_obj_t * btn = NULL;
-
-        lv_coord_t btn_h = lv_obj_get_height_fit(header);
-        lv_coord_t btn_w = ext->btn_w != 0 ? ext->btn_w : btn_h;
-
-        /*Get x position of the title (should be on the right of the buttons on the left)*/
-
-        lv_coord_t left_btn_offset = 0;
-        btn = lv_obj_get_child_back(ext->header, NULL);
-        while(btn != NULL) {
-            if(LV_WIN_BTN_ALIGN_LEFT == lv_win_btn_get_alignment(btn)) {
-                left_btn_offset += btn_w + header_inner;
-            }
-
-            btn = lv_obj_get_child_back(header, btn);
-        }
-
-        txt_area.x1 = header->coords.x1 + header_left + left_btn_offset;
-        txt_area.y1 = header->coords.y1 + (lv_obj_get_height(header) - txt_size.y) / 2;
-        txt_area.x2 = txt_area.x1 + txt_size.x  + left_btn_offset;
-        txt_area.y2 = txt_area.y1 + txt_size.y;
-
-        lv_draw_label(&txt_area, clip_area, &label_dsc, ext->title_txt, NULL);
-    }
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_header_design(header, clip_area, mode);
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-/**
- * Signal function of the window
- * @param win pointer to a window object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_win_get_style(win, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(win, sign, param);
-    }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-        lv_get_state_info_t * info = param;
-        if(info->part == LV_WIN_PART_CONTENT_SCROLLABLE) info->result = lv_obj_get_state(lv_page_get_scrollable(ext->page),
-                                                                                             LV_CONT_PART_MAIN);
-        else if(info->part == LV_WIN_PART_SCROLLBAR) info->result = lv_obj_get_state(ext->page, LV_PAGE_PART_SCROLLBAR);
-        else if(info->part == LV_WIN_PART_HEADER) info->result = lv_obj_get_state(ext->header, LV_OBJ_PART_MAIN);
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(win, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    if(sign == LV_SIGNAL_CHILD_CHG) { /*Move children to the page*/
-        lv_obj_t * page = ext->page;
-        if(page != NULL) {
-            lv_obj_t * child;
-            child = lv_obj_get_child(win, NULL);
-            while(child != NULL) {
-                if(lv_obj_is_protected(child, LV_PROTECT_PARENT) == false) {
-                    lv_obj_t * tmp = child;
-                    child          = lv_obj_get_child(win, child); /*Get the next child before move this*/
-                    lv_obj_set_parent(tmp, page);
-                }
-                else {
-                    child = lv_obj_get_child(win, child);
-                }
-            }
-        }
-    }
-    else if(sign == LV_SIGNAL_STYLE_CHG) {
-        lv_win_realign(win);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        /*If the size is changed refresh the window*/
-        if(lv_area_get_width(param) != lv_obj_get_width(win) || lv_area_get_height(param) != lv_obj_get_height(win)) {
-            lv_win_realign(win);
-        }
-    }
-    else if(sign == LV_SIGNAL_CLEANUP) {
-        ext->header = NULL; /*These objects were children so they are already invalid*/
-        ext->page   = NULL;
-        lv_mem_free(ext->title_txt);
-        ext->title_txt  = NULL;
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        /*Forward all the control signals to the page*/
-        ext->page->signal_cb(ext->page, sign, param);
-#endif
-    }
-
-    return res;
-}
-/**
- * Get the style descriptor of a part of the object
- * @param win pointer the object
- * @param part the part of the win. (LV_PAGE_WIN_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_win_get_style(lv_obj_t * win, uint8_t part)
-{
-    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
-
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-    lv_style_list_t * style_dsc_p;
-
-    switch(part) {
-        case LV_WIN_PART_BG:
-            style_dsc_p = &win->style_list;
-            break;
-        case LV_WIN_PART_HEADER:
-            style_dsc_p = lv_obj_get_style_list(ext->header, LV_OBJ_PART_MAIN);
-            break;
-        case LV_WIN_PART_SCROLLBAR:
-            style_dsc_p = lv_obj_get_style_list(ext->page, LV_PAGE_PART_SCROLLBAR);
-            break;
-        case LV_WIN_PART_CONTENT_SCROLLABLE:
-            style_dsc_p = lv_obj_get_style_list(ext->page, LV_PAGE_PART_SCROLLABLE);
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-/**
- * Realign the building elements of a window
- * @param win pointer to a window object
- */
-static void lv_win_realign(lv_obj_t * win)
-{
-    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
-
-    if(ext->page == NULL || ext->header == NULL) return;
-
-    lv_obj_set_width(ext->header, lv_obj_get_width(win));
-
-    lv_obj_t * btn;
-    lv_obj_t * btn_prev_at_left = NULL;
-    lv_obj_t * btn_prev_at_right = NULL;
-
-    bool is_header_right_side_empty = true;
-    bool is_header_left_side_empty = true;
-
-    lv_coord_t btn_h = lv_obj_get_height_fit(ext->header);
-    lv_coord_t btn_w = ext->btn_w != 0 ? ext->btn_w : btn_h;
-    lv_style_int_t header_inner = lv_obj_get_style_pad_inner(win, LV_WIN_PART_HEADER);
-    lv_style_int_t header_right = lv_obj_get_style_pad_right(win, LV_WIN_PART_HEADER);
-    lv_style_int_t header_left = lv_obj_get_style_pad_left(win, LV_WIN_PART_HEADER);
-
-    /*Refresh the size of all control buttons*/
-    btn = lv_obj_get_child_back(ext->header, NULL);
-    while(btn != NULL) {
-        lv_obj_set_size(btn, btn_w, btn_h);
-        uint8_t btn_alignment = lv_win_btn_get_alignment(btn);
-
-        if(LV_WIN_BTN_ALIGN_RIGHT == btn_alignment) {
-            if(is_header_right_side_empty) {
-                /* Align the button to the right of the header */
-                lv_obj_align(btn, ext->header, LV_ALIGN_IN_RIGHT_MID, -header_right, 0);
-
-                is_header_right_side_empty = false;
-            }
-            else {
-                /* Align the button to the left of the previous button */
-                lv_obj_align(btn, btn_prev_at_right, LV_ALIGN_OUT_LEFT_MID, -header_inner, 0);
-            }
-
-            btn_prev_at_right = btn;
-        }
-        else if(LV_WIN_BTN_ALIGN_LEFT == btn_alignment) {
-            if(is_header_left_side_empty) {
-                /* Align the button to the right of the header */
-                lv_obj_align(btn, ext->header, LV_ALIGN_IN_LEFT_MID, header_left, 0);
-
-                is_header_left_side_empty = false;
-            }
-            else {
-                /* Align the button to the right of the previous button */
-                lv_obj_align(btn, btn_prev_at_left, LV_ALIGN_OUT_RIGHT_MID, header_inner, 0);
-            }
-
-            btn_prev_at_left = btn;
-        }
-
-        btn = lv_obj_get_child_back(ext->header, btn);
-    }
-
-    lv_obj_set_pos(ext->header, 0, 0);
-
-    lv_obj_set_size(ext->page, lv_obj_get_width(win), lv_obj_get_height(win) - lv_obj_get_height(ext->header));
-    lv_obj_align(ext->page, ext->header, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
-}
-
-static lv_obj_t * lv_win_btn_create(lv_obj_t * par, const void * img_src)
-{
-    LV_LOG_TRACE("win btn create started");
-
-    lv_obj_t * win_btn;
-
-    win_btn = lv_btn_create(par, NULL);
-    LV_ASSERT_MEM(win_btn);
-    if(win_btn == NULL) return NULL;
-
-    /*Allocate the extended data*/
-    lv_win_btn_ext_t * ext = lv_obj_allocate_ext_attr(win_btn, sizeof(lv_win_btn_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(win_btn);
-        return NULL;
-    }
-
-    ext->alignment_in_header = LV_WIN_BTN_ALIGN_RIGHT;
-
-    lv_obj_set_click(win_btn, true);
-    lv_win_btn_set_alignment(win_btn, LV_WIN_BTN_ALIGN_RIGHT);
-
-    lv_theme_apply(win_btn, LV_THEME_WIN_BTN);
-    lv_coord_t btn_size = lv_obj_get_height_fit(par);
-    lv_obj_set_size(win_btn, btn_size, btn_size);
-
-    lv_obj_t * img = lv_img_create(win_btn, NULL);
-    lv_obj_set_click(img, false);
-    lv_img_set_src(img, img_src);
-
-    LV_LOG_INFO("win btn created");
-
-    return win_btn;
-}
-
-static void lv_win_btn_set_alignment(lv_obj_t * win_btn, const uint8_t alignment)
-{
-    lv_win_btn_ext_t * ext = lv_obj_get_ext_attr(win_btn);
-
-    ext->alignment_in_header = alignment;
-}
-
-static uint8_t lv_win_btn_get_alignment(const lv_obj_t * win_btn)
-{
-    lv_win_btn_ext_t * ext = lv_obj_get_ext_attr(win_btn);
-
-    return ext->alignment_in_header;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_win.h b/src/lv_widgets/lv_win.h
deleted file mode 100644
index c3efb3d63..000000000
--- a/src/lv_widgets/lv_win.h
+++ /dev/null
@@ -1,300 +0,0 @@
-/**
- * @file lv_win.h
- *
- */
-
-#ifndef LV_WIN_H
-#define LV_WIN_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_conf_internal.h"
-
-#if LV_USE_WIN != 0
-
-/*Testing of dependencies*/
-#if LV_USE_BTN == 0
-#error "lv_win: lv_btn is required. Enable it in lv_conf.h (LV_USE_BTN  1) "
-#endif
-
-#if LV_USE_LABEL == 0
-#error "lv_win: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
-#endif
-
-#if LV_USE_IMG == 0
-#error "lv_win: lv_img is required. Enable it in lv_conf.h (LV_USE_IMG  1) "
-#endif
-
-#if LV_USE_PAGE == 0
-#error "lv_win: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE  1) "
-#endif
-
-#include "../lv_core/lv_obj.h"
-#include "lv_cont.h"
-#include "lv_btn.h"
-#include "lv_label.h"
-#include "lv_img.h"
-#include "lv_page.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of window*/
-typedef struct {
-    /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * page;                  /*Pointer to a page which holds the content*/
-    lv_obj_t * header;                /*Pointer to the header container of the window*/
-    char * title_txt;                 /*Pointer to the title label of the window*/
-    lv_coord_t btn_w;                 /*Width of the control buttons*/
-} lv_win_ext_t;
-
-/** Window parts. */
-enum {
-    LV_WIN_PART_BG = LV_OBJ_PART_MAIN, /**< Window object background style. */
-    _LV_WIN_PART_VIRTUAL_LAST,
-    LV_WIN_PART_HEADER = _LV_OBJ_PART_REAL_LAST, /**< Window titlebar background style. */
-    LV_WIN_PART_CONTENT_SCROLLABLE, /**< Window content style. */
-    LV_WIN_PART_SCROLLBAR, /**< Window scrollbar style. */
-    _LV_WIN_PART_REAL_LAST
-};
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a window objects
- * @param par pointer to an object, it will be the parent of the new window
- * @param copy pointer to a window object, if not NULL then the new object will be copied from it
- * @return pointer to the created window
- */
-lv_obj_t * lv_win_create(lv_obj_t * par, const lv_obj_t * copy);
-
-/**
- * Delete all children of the scrl object, without deleting scrl child.
- * @param win pointer to an object
- */
-void lv_win_clean(lv_obj_t * win);
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/**
- * Add control button on the right side of the window header
- * @param win pointer to a window object
- * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
- * @return pointer to the created button object
- */
-lv_obj_t * lv_win_add_btn_right(lv_obj_t * win, const void * img_src);
-
-/**
- * Add control button on the left side of the window header
- * @param win pointer to a window object
- * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
- * @return pointer to the created button object
- */
-lv_obj_t * lv_win_add_btn_left(lv_obj_t * win, const void * img_src);
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Can be assigned to a window control button to close the window
- * @param btn pointer to the control button on the widows header
- * @param evet the event type
- */
-void lv_win_close_event_cb(lv_obj_t * btn, lv_event_t event);
-
-/**
- * Set the title of a window
- * @param win pointer to a window object
- * @param title string of the new title
- */
-void lv_win_set_title(lv_obj_t * win, const char * title);
-
-/**
- * Set the control button size of a window
- * @param win pointer to a window object
- * @return control button size
- */
-void lv_win_set_header_height(lv_obj_t * win, lv_coord_t size);
-
-/**
- * Set the width of the control buttons on the header
- * @param win pointer to a window object
- * @param width width of the control button. 0: to make them square automatically.
- */
-void lv_win_set_btn_width(lv_obj_t * win, lv_coord_t width);
-
-/**
- * Set the size of the content area.
- * @param win pointer to a window object
- * @param w width
- * @param h height (the window will be higher with the height of the header)
- */
-void lv_win_set_content_size(lv_obj_t * win, lv_coord_t w, lv_coord_t h);
-
-/**
- * Set the layout of the window
- * @param win pointer to a window object
- * @param layout the layout from 'lv_layout_t'
- */
-void lv_win_set_layout(lv_obj_t * win, lv_layout_t layout);
-
-/**
- * Set the scroll bar mode of a window
- * @param win pointer to a window object
- * @param sb_mode the new scroll bar mode from  'lv_scrollbar_mode_t'
- */
-void lv_win_set_scrollbar_mode(lv_obj_t * win, lv_scrollbar_mode_t sb_mode);
-
-/**
- * Set focus animation duration on `lv_win_focus()`
- * @param win pointer to a window object
- * @param anim_time duration of animation [ms]
- */
-void lv_win_set_anim_time(lv_obj_t * win, uint16_t anim_time);
-
-/**
- * Set drag status of a window. If set to 'true' window can be dragged like on a PC.
- * @param win pointer to a window object
- * @param en whether dragging is enabled
- */
-void lv_win_set_drag(lv_obj_t * win, bool en);
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the title of a window
- * @param win pointer to a window object
- * @return title string of the window
- */
-const char * lv_win_get_title(const lv_obj_t * win);
-
-/**
- * Get the content holder object of window (`lv_page`) to allow additional customization
- * @param win pointer to a window object
- * @return the Page object where the window's content is
- */
-lv_obj_t * lv_win_get_content(const lv_obj_t * win);
-
-/**
- * Get the header height
- * @param win pointer to a window object
- * @return header height
- */
-lv_coord_t lv_win_get_header_height(const lv_obj_t * win);
-
-
-/**
- * Get the width of the control buttons on the header
- * @param win pointer to a window object
- * @return width of the control button. 0: square.
- */
-lv_coord_t lv_win_get_btn_width(lv_obj_t * win);
-
-/**
- * Get the pointer of a widow from one of  its control button.
- * It is useful in the action of the control buttons where only button is known.
- * @param ctrl_btn pointer to a control button of a window
- * @return pointer to the window of 'ctrl_btn'
- */
-lv_obj_t * lv_win_get_from_btn(const lv_obj_t * ctrl_btn);
-
-/**
- * Get the layout of a window
- * @param win pointer to a window object
- * @return the layout of the window (from 'lv_layout_t')
- */
-lv_layout_t lv_win_get_layout(lv_obj_t * win);
-
-/**
- * Get the scroll bar mode of a window
- * @param win pointer to a window object
- * @return the scroll bar mode of the window (from 'lv_sb_mode_t')
- */
-lv_scrollbar_mode_t lv_win_get_sb_mode(lv_obj_t * win);
-
-/**
- * Get focus animation duration
- * @param win pointer to a window object
- * @return duration of animation [ms]
- */
-uint16_t lv_win_get_anim_time(const lv_obj_t * win);
-
-/**
- * Get width of the content area (page scrollable) of the window
- * @param win pointer to a window object
- * @return the width of the content area
- */
-lv_coord_t lv_win_get_width(lv_obj_t * win);
-
-/**
- * Get drag status of a window. If set to 'true' window can be dragged like on a PC.
- * @param win pointer to a window object
- * @return whether window is draggable
- */
-static inline bool lv_win_get_drag(const lv_obj_t * win)
-{
-    return lv_obj_get_drag(win);
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/**
- * Focus on an object. It ensures that the object will be visible in the window.
- * @param win pointer to a window object
- * @param obj pointer to an object to focus (must be in the window)
- * @param anim_en LV_ANIM_ON focus with an animation; LV_ANIM_OFF focus without animation
- */
-void lv_win_focus(lv_obj_t * win, lv_obj_t * obj, lv_anim_enable_t anim_en);
-
-/**
- * Scroll the window horizontally
- * @param win pointer to a window object
- * @param dist the distance to scroll (< 0: scroll right; > 0 scroll left)
- */
-static inline void lv_win_scroll_hor(lv_obj_t * win, lv_coord_t dist)
-{
-    lv_win_ext_t * ext = (lv_win_ext_t *)lv_obj_get_ext_attr(win);
-    lv_page_scroll_hor(ext->page, dist);
-}
-/**
- * Scroll the window vertically
- * @param win pointer to a window object
- * @param dist the distance to scroll (< 0: scroll down; > 0 scroll up)
- */
-static inline void lv_win_scroll_ver(lv_obj_t * win, lv_coord_t dist)
-{
-    lv_win_ext_t * ext = (lv_win_ext_t *)lv_obj_get_ext_attr(win);
-    lv_page_scroll_ver(ext->page, dist);
-}
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_USE_WIN*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_WIN_H*/

From fceb1177cdcdc3a181b0c9016b605c7a857f9d0a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 15 Sep 2020 10:16:15 +0200
Subject: [PATCH 33/84] start to rework widgets

---
 src/lv_core/lv_obj.c              | 47 ++++++++++++++-
 src/lv_core/lv_obj.h              |  5 +-
 src/lv_hal/lv_hal_disp.c          |  6 +-
 src/lv_themes/lv_theme.c          |  6 +-
 src/lv_themes/lv_theme_material.c |  6 +-
 src/lv_themes/lv_theme_mono.c     | 14 ++---
 src/lv_themes/lv_theme_template.c |  6 +-
 src/lv_widgets/lv_bar.c           | 96 +++++++++++++++----------------
 src/lv_widgets/lv_bar.h           |  8 +--
 src/lv_widgets/lv_btn.c           | 20 ++++---
 src/lv_widgets/lv_btn.h           |  4 +-
 src/lv_widgets/lv_checkbox.h      | 11 ++--
 src/lv_widgets/lv_label.c         |  6 +-
 src/lv_widgets/lv_label.h         |  4 +-
 src/lv_widgets/lv_slider.c        | 57 +++++++-----------
 src/lv_widgets/lv_slider.h        | 19 +++---
 src/lv_widgets/lv_switch.c        | 45 +++++++--------
 src/lv_widgets/lv_switch.h        | 12 ++--
 18 files changed, 201 insertions(+), 171 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 0b0f40944..4496d0d0b 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -180,9 +180,12 @@ void lv_deinit(void)
  * Create a basic object
  * @param parent pointer to a parent object.
  *                  If NULL then a screen will be created
+ *
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other base object to copy.
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent)
+lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy)
 {
     lv_obj_t * new_obj = NULL;
 
@@ -290,9 +293,47 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent)
     new_obj->ext_attr = NULL;
 
     lv_style_list_init(&new_obj->style_list);
-    if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
-    else  lv_theme_apply(new_obj, LV_THEME_SCR);
+    lv_style_list_init(&new_obj->style_list);
+     if(copy == NULL) {
+         if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
+         else  lv_theme_apply(new_obj, LV_THEME_SCR);
+     }
+     else {
+         lv_style_list_copy(&new_obj->style_list, &copy->style_list);
+     }
+     /*Copy the attributes if required*/
+     if(copy != NULL) {
+         lv_area_copy(&new_obj->coords, &copy->coords);
+         new_obj->ext_draw_pad = copy->ext_draw_pad;
 
+ #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
+         lv_area_copy(&new_obj->ext_click_pad, &copy->ext_click_pad);
+ #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
+         new_obj->ext_click_pad = copy->ext_click_pad;
+ #endif
+
+         /*Set user data*/
+ #if LV_USE_USER_DATA
+         _lv_memcpy(&new_obj->user_data, &copy->user_data, sizeof(lv_obj_user_data_t));
+ #endif
+         /*Only copy the `event_cb`. `signal_cb` and `design_cb` will be copied in the derived
+          * object type (e.g. `lv_btn`)*/
+         new_obj->event_cb = copy->event_cb;
+
+         new_obj->flags  = copy->flags;
+
+ #if LV_USE_GROUP
+         /*Add to the same group*/
+         if(copy->group_p != NULL) {
+             lv_group_add_obj(copy->group_p, new_obj);
+         }
+ #endif
+
+         /*Set the same coordinates for non screen objects*/
+         if(lv_obj_get_parent(copy) != NULL && parent != NULL) {
+             lv_obj_set_pos(new_obj, lv_obj_get_x(copy), lv_obj_get_y(copy));
+         }
+     }
     lv_obj_set_pos(new_obj, 0, 0);
 
     /*Send a signal to the parent to notify it about the new child*/
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 3f5477379..c663a0b3a 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -308,9 +308,12 @@ void lv_deinit(void);
  * Create a basic object
  * @param parent pointer to a parent object.
  *                  If NULL then a screen will be created
+ *
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other base object to copy.
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent);
+lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy);
 
 /**
  * Delete 'obj' and all of its children
diff --git a/src/lv_hal/lv_hal_disp.c b/src/lv_hal/lv_hal_disp.c
index fac9f1a0b..3e7a33c67 100644
--- a/src/lv_hal/lv_hal_disp.c
+++ b/src/lv_hal/lv_hal_disp.c
@@ -153,9 +153,9 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
 #endif
 
     disp->prev_scr  = NULL;
-    disp->act_scr   = lv_obj_create(NULL); /*Create a default screen on the display*/
-    disp->top_layer = lv_obj_create(NULL); /*Create top layer on the display*/
-    disp->sys_layer = lv_obj_create(NULL); /*Create sys layer on the display*/
+    disp->act_scr   = lv_obj_create(NULL, NULL); /*Create a default screen on the display*/
+    disp->top_layer = lv_obj_create(NULL, NULL); /*Create top layer on the display*/
+    disp->sys_layer = lv_obj_create(NULL, NULL); /*Create sys layer on the display*/
     lv_obj_reset_style_list(disp->top_layer, LV_OBJ_PART_MAIN);
     lv_obj_reset_style_list(disp->sys_layer, LV_OBJ_PART_MAIN);
     lv_obj_clear_flag(disp->top_layer, LV_OBJ_FLAG_CLICKABLE);
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index e5db6d723..08b7fc8d8 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -239,14 +239,14 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            _lv_obj_reset_style_list_no_refr(obj, LV_BAR_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BAR_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_BAR_PART_INDIC);
             break;
 #endif
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_INDIC);
             _lv_obj_reset_style_list_no_refr(obj, LV_SWITCH_PART_KNOB);
             break;
@@ -298,7 +298,7 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_INDIC);
             _lv_obj_reset_style_list_no_refr(obj, LV_SLIDER_PART_KNOB);
             break;
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 09e4ba037..ca6b3e460 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -1019,7 +1019,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
             list = _lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
@@ -1029,7 +1029,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
             list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
@@ -1093,7 +1093,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bar_bg);
             _lv_style_list_add_style(list, &styles->slider_bg);
 
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index 42e5b0ed5..bf934c9f1 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -381,13 +381,7 @@ static void slider_init(void)
 static void switch_init(void)
 {
 #if LV_USE_SWITCH != 0
-    style_init_reset(&styles->sb);
-    lv_style_set_bg_opa(&styles->sb, LV_STATE_DEFAULT, LV_OPA_COVER);
-    lv_style_set_bg_color(&styles->sb, LV_STATE_DEFAULT, FG_COLOR);
-    lv_style_set_radius(&styles->sb, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-    lv_style_set_pad_right(&styles->sb, LV_STATE_DEFAULT, LV_DPI / 30);
-    lv_style_set_pad_bottom(&styles->sb, LV_STATE_DEFAULT, LV_DPI / 30);
-    lv_style_set_size(&styles->sb, LV_STATE_DEFAULT, LV_MATH_MAX(LV_DPI / 25, 3));
+
 #endif
 }
 
@@ -620,7 +614,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
@@ -634,7 +628,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
@@ -705,7 +699,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
 
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index 63bccb2c5..8d3e87508 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -461,7 +461,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            list = _lv_obj_get_style_list(obj, LV_BAR_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BAR_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
 
@@ -473,7 +473,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SWITCH_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             _lv_style_list_add_style(list, &styles->round);
@@ -548,7 +548,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
             list = _lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
diff --git a/src/lv_widgets/lv_bar.c b/src/lv_widgets/lv_bar.c
index acd90fdb2..b08e409b1 100644
--- a/src/lv_widgets/lv_bar.c
+++ b/src/lv_widgets/lv_bar.c
@@ -56,7 +56,7 @@ static void lv_bar_anim_ready(lv_anim_t * a);
 /**********************
  *  STATIC VARIABLES
  **********************/
-static lv_design_cb_t ancestor_design_f;
+static lv_design_cb_t ancestor_design;
 static lv_signal_cb_t ancestor_signal;
 
 /**********************
@@ -70,20 +70,21 @@ static lv_signal_cb_t ancestor_signal;
 /**
  * Create a bar objects
  * @param par pointer to an object, it will be the parent of the new bar
- * @param copy pointer to a bar object, if not NULL then the new object will be copied from it
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other bar to copy.
  * @return pointer to the created bar
  */
-lv_obj_t * lv_bar_create(lv_obj_t * par, const lv_obj_t * copy)
+lv_obj_t * lv_bar_create(lv_obj_t * parent, lv_obj_t * copy)
 {
     LV_LOG_TRACE("lv_bar create started");
 
     /*Create the ancestor basic object*/
-    lv_obj_t * bar = lv_obj_create(par, copy);
+    lv_obj_t * bar = lv_obj_create(parent, copy);
     LV_ASSERT_MEM(bar);
     if(bar == NULL) return NULL;
 
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(bar);
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_cb(bar);
+    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(bar);
 
     /*Allocate the object type specific extended data*/
     lv_bar_ext_t * ext = lv_obj_allocate_ext_attr(bar, sizeof(lv_bar_ext_t));
@@ -109,32 +110,27 @@ lv_obj_t * lv_bar_create(lv_obj_t * par, const lv_obj_t * copy)
     lv_obj_set_signal_cb(bar, lv_bar_signal);
     lv_obj_set_design_cb(bar, lv_bar_design);
 
-
-    /*Init the new  bar object*/
     if(copy == NULL) {
-
-        lv_obj_set_click(bar, false);
+        lv_obj_clear_flag(bar, LV_OBJ_FLAG_CHECKABLE);
         lv_obj_set_size(bar, LV_DPI * 2, LV_DPI / 10);
         lv_bar_set_value(bar, ext->cur_value, false);
 
         lv_theme_apply(bar, LV_THEME_BAR);
+    } else {
+          lv_bar_ext_t * ext_copy = lv_obj_get_ext_attr(copy);
+          ext->min_value          = ext_copy->min_value;
+          ext->start_value        = ext_copy->start_value;
+          ext->max_value          = ext_copy->max_value;
+          ext->cur_value          = ext_copy->cur_value;
+          ext->type                = ext_copy->type;
+
+          lv_style_list_copy(&ext->style_indic, &ext_copy->style_indic);
+
+          /*Refresh the style with new signal function*/
+          _lv_obj_refresh_style(bar, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+
+          lv_bar_set_value(bar, ext->cur_value, LV_ANIM_OFF);
     }
-    else {
-        lv_bar_ext_t * ext_copy = lv_obj_get_ext_attr(copy);
-        ext->min_value          = ext_copy->min_value;
-        ext->start_value        = ext_copy->start_value;
-        ext->max_value          = ext_copy->max_value;
-        ext->cur_value          = ext_copy->cur_value;
-        ext->type                = ext_copy->type;
-
-        lv_style_list_copy(&ext->style_indic, &ext_copy->style_indic);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(bar, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-
-        lv_bar_set_value(bar, ext->cur_value, LV_ANIM_OFF);
-    }
-
     LV_LOG_INFO("bar created");
 
     return bar;
@@ -371,7 +367,7 @@ static lv_design_res_t lv_bar_design(lv_obj_t * bar, const lv_area_t * clip_area
 {
     if(mode == LV_DESIGN_COVER_CHK) {
         /*Return false if the object is not covers the mask area*/
-        return ancestor_design_f(bar, clip_area, mode);
+        return ancestor_design(bar, clip_area, mode);
     }
     else if(mode == LV_DESIGN_DRAW_MAIN) {
         draw_bg(bar, clip_area);
@@ -385,7 +381,7 @@ static lv_design_res_t lv_bar_design(lv_obj_t * bar, const lv_area_t * clip_area
         draw_dsc.shadow_opa = LV_OPA_TRANSP;
         draw_dsc.pattern_opa = LV_OPA_TRANSP;
         draw_dsc.outline_opa = LV_OPA_TRANSP;
-        lv_obj_init_draw_rect_dsc(bar, LV_BAR_PART_BG, &draw_dsc);
+        lv_obj_init_draw_rect_dsc(bar, LV_BAR_PART_MAIN, &draw_dsc);
         lv_draw_rect(&bar->coords, clip_area, &draw_dsc);
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
@@ -412,13 +408,13 @@ static void draw_bg(lv_obj_t * bar, const lv_area_t * clip_area)
     lv_draw_rect_dsc_t draw_dsc;
     lv_draw_rect_dsc_init(&draw_dsc);
     /*If the border is drawn later disable loading its properties*/
-    if(lv_obj_get_style_border_post(bar, LV_BAR_PART_BG)) {
+    if(lv_obj_get_style_border_post(bar, LV_BAR_PART_MAIN)) {
         draw_dsc.border_opa = LV_OPA_TRANSP;
     }
 
     /*value will be drawn later*/
     draw_dsc.value_opa = LV_OPA_TRANSP;
-    lv_obj_init_draw_rect_dsc(bar, LV_BAR_PART_BG, &draw_dsc);
+    lv_obj_init_draw_rect_dsc(bar, LV_BAR_PART_MAIN, &draw_dsc);
     lv_draw_rect(&bar->coords, clip_area, &draw_dsc);
 
 }
@@ -437,10 +433,10 @@ static void draw_indic(lv_obj_t * bar, const lv_area_t * clip_area)
        ext->start_value == ext->min_value) sym = true;
 
     /*Calculate the indicator area*/
-    lv_style_int_t bg_left = lv_obj_get_style_pad_left(bar,     LV_BAR_PART_BG);
-    lv_style_int_t bg_right = lv_obj_get_style_pad_right(bar,   LV_BAR_PART_BG);
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(bar,       LV_BAR_PART_BG);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(bar, LV_BAR_PART_BG);
+    lv_style_int_t bg_left = lv_obj_get_style_pad_left(bar,     LV_BAR_PART_MAIN);
+    lv_style_int_t bg_right = lv_obj_get_style_pad_right(bar,   LV_BAR_PART_MAIN);
+    lv_style_int_t bg_top = lv_obj_get_style_pad_top(bar,       LV_BAR_PART_MAIN);
+    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(bar, LV_BAR_PART_MAIN);
 
     /*Respect padding and minimum width/height too*/
     lv_area_copy(&ext->indic_area, &bar->coords);
@@ -550,7 +546,7 @@ static void draw_indic(lv_obj_t * bar, const lv_area_t * clip_area)
     /*Do not draw a zero length indicator*/
     if(!sym && indic_length_calc(&ext->indic_area) <= 1) return;
 
-    uint16_t bg_radius = lv_obj_get_style_radius(bar, LV_BAR_PART_BG);
+    uint16_t bg_radius = lv_obj_get_style_radius(bar, LV_BAR_PART_MAIN);
     lv_coord_t short_side = LV_MATH_MIN(objw, objh);
     if(bg_radius > short_side >> 1) bg_radius = short_side >> 1;
 
@@ -645,29 +641,29 @@ static lv_res_t lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
 {
     lv_res_t res;
 
+    /* Include the ancient signal function */
+    res = ancestor_signal(bar, sign, param);
+    if(res != LV_RES_OK) return res;
+
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         info->result = lv_bar_get_style(bar, info->part);
         if(info->result != NULL) return LV_RES_OK;
         else return ancestor_signal(bar, sign, param);
     }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(bar, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-
+    else if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         lv_coord_t indic_size;
-        indic_size = lv_obj_get_draw_rect_ext_pad_size(bar, LV_BAR_PART_INDIC);
+        indic_size = _lv_obj_get_draw_rect_ext_pad_size(bar, LV_BAR_PART_INDIC);
 
         /*Bg size is handled by lv_obj*/
         bar->ext_draw_pad = LV_MATH_MAX(bar->ext_draw_pad, indic_size);
 
     }
     if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(bar, LV_BAR_PART_INDIC);
+        _lv_obj_reset_style_list_no_refr(bar, LV_BAR_PART_INDIC);
 #if LV_USE_ANIMATION
         lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
         lv_anim_del(&ext->cur_value_anim, NULL);
@@ -683,20 +679,20 @@ static lv_style_list_t * lv_bar_get_style(lv_obj_t * bar, uint8_t part)
     LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
 
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
-    lv_style_list_t * style_dsc_p;
+    lv_style_list_t * list;
 
     switch(part) {
-        case LV_BAR_PART_BG:
-            style_dsc_p = &bar->style_list;
+        case LV_BAR_PART_MAIN:
+            list = &bar->style_list;
             break;
         case LV_BAR_PART_INDIC:
-            style_dsc_p = &ext->style_indic;
+            list = &ext->style_indic;
             break;
         default:
-            style_dsc_p = NULL;
+            list = NULL;
     }
 
-    return style_dsc_p;
+    return list;
 }
 
 #if LV_USE_ANIMATION
diff --git a/src/lv_widgets/lv_bar.h b/src/lv_widgets/lv_bar.h
index 3c8de853b..6a761921f 100644
--- a/src/lv_widgets/lv_bar.h
+++ b/src/lv_widgets/lv_bar.h
@@ -19,7 +19,6 @@ extern "C" {
 
 #include "../lv_core/lv_obj.h"
 #include "../lv_misc/lv_anim.h"
-#include "lv_cont.h"
 #include "lv_btn.h"
 #include "lv_label.h"
 
@@ -80,7 +79,7 @@ typedef struct {
 
 /** Bar parts */
 enum {
-    LV_BAR_PART_BG, /** Bar background style. */
+    LV_BAR_PART_MAIN, /** Bar background style. */
     LV_BAR_PART_INDIC, /** Bar fill area style. */
     _LV_BAR_PART_VIRTUAL_LAST
 };
@@ -93,10 +92,11 @@ typedef uint8_t lv_bar_part_t;
 /**
  * Create a bar objects
  * @param par pointer to an object, it will be the parent of the new bar
- * @param copy pointer to a bar object, if not NULL then the new object will be copied from it
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other bar to copy.
  * @return pointer to the created bar
  */
-lv_obj_t * lv_bar_create(lv_obj_t * par, const lv_obj_t * copy);
+lv_obj_t * lv_bar_create(lv_obj_t * parent, lv_obj_t * copy);
 
 /*=====================
  * Setter functions
diff --git a/src/lv_widgets/lv_btn.c b/src/lv_widgets/lv_btn.c
index 1003d84b1..376999675 100644
--- a/src/lv_widgets/lv_btn.c
+++ b/src/lv_widgets/lv_btn.c
@@ -49,15 +49,17 @@ static lv_signal_cb_t ancestor_signal;
 /**
  * Create a button object
  * @param parent pointer to an object, it will be the parent of the new button
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other button to copy.
  * @return pointer to the created button
  */
-lv_obj_t * lv_btn_create(lv_obj_t * parent)
+lv_obj_t * lv_btn_create(lv_obj_t * parent, const lv_obj_t * copy)
 {
     LV_LOG_TRACE("button create started");
 
     lv_obj_t * btn;
 
-    btn = lv_obj_create(parent);
+    btn = lv_obj_create(parent, copy);
     LV_ASSERT_MEM(btn);
     if(btn == NULL) return NULL;
 
@@ -65,13 +67,15 @@ lv_obj_t * lv_btn_create(lv_obj_t * parent)
 
     lv_obj_set_signal_cb(btn, lv_btn_signal);
 
-    /*Set layout if the button is not a screen*/
-    if(parent) {
-        lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
-        lv_obj_set_grid(btn, &lv_grid_center);
-    }
+    if(copy == NULL) {
+        /*Set layout if the button is not a screen*/
+        if(parent) {
+            lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
+            lv_obj_set_grid(btn, &lv_grid_center);
+        }
 
-    lv_theme_apply(btn, LV_THEME_BTN);
+        lv_theme_apply(btn, LV_THEME_BTN);
+    }
 
     LV_LOG_INFO("button created");
 
diff --git a/src/lv_widgets/lv_btn.h b/src/lv_widgets/lv_btn.h
index 721d2b5a1..4421933f5 100644
--- a/src/lv_widgets/lv_btn.h
+++ b/src/lv_widgets/lv_btn.h
@@ -40,9 +40,11 @@ typedef uint8_t lv_btn_part_t;
 /**
  * Create a button object
  * @param parent pointer to an object, it will be the parent of the new button
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other button to copy.
  * @return pointer to the created button
  */
-lv_obj_t * lv_btn_create(lv_obj_t * parent);
+lv_obj_t * lv_btn_create(lv_obj_t * parent, const lv_obj_t * copy);
 
 /*=====================
  * Setter functions
diff --git a/src/lv_widgets/lv_checkbox.h b/src/lv_widgets/lv_checkbox.h
index 96bb0f1e2..7576a76d9 100644
--- a/src/lv_widgets/lv_checkbox.h
+++ b/src/lv_widgets/lv_checkbox.h
@@ -40,18 +40,17 @@ extern "C" {
 
 /*Data of check box*/
 typedef struct {
-    lv_btn_ext_t bg_btn; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * bullet; /*Pointer to button*/
+    /*No inherited ext, derived from the base object */
+
+    /*New data for this widget */
+    lv_obj_t * text; /*Pointer to button*/
     lv_obj_t * label;  /*Pointer to label*/
 } lv_checkbox_ext_t;
 
 /** Checkbox styles. */
 enum {
-    LV_CHECKBOX_PART_BG = LV_BTN_PART_MAIN,  /**< Style of object background. */
+    LV_CHECKBOX_PART_MAIN = LV_OBJ_PART_MAIN,  /**< Style of object background. */
     _LV_CHECKBOX_PART_VIRTUAL_LAST,
-    LV_CHECKBOX_PART_BULLET = _LV_BTN_PART_REAL_LAST, /**< Style of box (released). */
-    _LV_CHECKBOX_PART_REAL_LAST
 };
 typedef uint8_t lv_checkbox_style_t;
 
diff --git a/src/lv_widgets/lv_label.c b/src/lv_widgets/lv_label.c
index bef0ec357..52ae3bc5b 100644
--- a/src/lv_widgets/lv_label.c
+++ b/src/lv_widgets/lv_label.c
@@ -71,14 +71,16 @@ static lv_signal_cb_t ancestor_signal;
 /**
  * Create a label objects
  * @param parent pointer to an object, it will be the parent of the new label
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other label to copy.
  * @return pointer to the created button
  */
-lv_obj_t * lv_label_create(lv_obj_t * parent)
+lv_obj_t * lv_label_create(lv_obj_t * parent, const lv_obj_t * copy)
 {
     LV_LOG_TRACE("label create started");
 
     /*Create a basic object*/
-    lv_obj_t * new_label = lv_obj_create(parent);
+    lv_obj_t * new_label = lv_obj_create(parent, copy);
     LV_ASSERT_MEM(new_label);
     if(new_label == NULL) return NULL;
 
diff --git a/src/lv_widgets/lv_label.h b/src/lv_widgets/lv_label.h
index 99e517e31..63da6d028 100644
--- a/src/lv_widgets/lv_label.h
+++ b/src/lv_widgets/lv_label.h
@@ -112,9 +112,11 @@ typedef uint8_t lv_label_part_t;
 /**
  * Create a label objects
  * @param parent pointer to an object, it will be the parent of the new label
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other label to copy.
  * @return pointer to the created button
  */
-lv_obj_t * lv_label_create(lv_obj_t * parent);
+lv_obj_t * lv_label_create(lv_obj_t * parent, const lv_obj_t * copy);
 
 /*=====================
  * Setter functions
diff --git a/src/lv_widgets/lv_slider.c b/src/lv_widgets/lv_slider.c
index 7e658226d..de18041d4 100644
--- a/src/lv_widgets/lv_slider.c
+++ b/src/lv_widgets/lv_slider.c
@@ -41,7 +41,7 @@ static void lv_slider_draw_knob(lv_obj_t * slider, const lv_area_t * knob_area,
 /**********************
  *  STATIC VARIABLES
  **********************/
-static lv_design_cb_t ancestor_design_f;
+static lv_design_cb_t ancestor_design;
 static lv_signal_cb_t ancestor_signal;
 
 /**********************
@@ -54,20 +54,21 @@ static lv_signal_cb_t ancestor_signal;
 
 /**
  * Create a slider objects
- * @param par pointer to an object, it will be the parent of the new slider
- * @param copy pointer to a slider object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new slider
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other slider to copy.
  * @return pointer to the created slider
  */
-lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy)
+lv_obj_t * lv_slider_create(lv_obj_t * parent, lv_obj_t * copy)
 {
     LV_LOG_TRACE("slider create started");
 
     /*Create the ancestor slider*/
-    lv_obj_t * slider = lv_bar_create(par, copy);
+    lv_obj_t * slider = lv_bar_create(parent, copy);
     LV_ASSERT_MEM(slider);
     if(slider == NULL) return NULL;
 
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_cb(slider);
+    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(slider);
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(slider);
 
     /*Allocate the slider type specific extended data*/
@@ -89,23 +90,20 @@ lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new slider slider*/
     if(copy == NULL) {
-        lv_obj_set_click(slider, true);
-        lv_obj_add_protect(slider, LV_PROTECT_PRESS_LOST);
-        lv_obj_set_ext_click_area(slider, 0, 0, LV_DPI / 10, LV_DPI / 10);
-
         lv_theme_apply(slider, LV_THEME_SLIDER);
+        lv_obj_add_flag(slider, LV_OBJ_FLAG_CHECKABLE);
+        lv_obj_set_ext_click_area(slider, 0, 0, LV_DPI / 10, LV_DPI / 10);
         lv_obj_set_height(slider, LV_DPI / 15);
-    }
-    /*Copy an existing slider*/
-    else {
+    } else {
         lv_slider_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
         lv_style_list_copy(&ext->style_knob, &copy_ext->style_knob);
         lv_area_copy(&ext->left_knob_area, &copy_ext->left_knob_area);
         lv_area_copy(&ext->right_knob_area, &copy_ext->right_knob_area);
 
-        lv_obj_refresh_style(slider, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(slider, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
+
     LV_LOG_INFO("slider created");
 
     return slider;
@@ -119,17 +117,6 @@ lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy)
  * Getter functions
  *====================*/
 
-/**
- * Get the value of a slider
- * @param slider pointer to a slider object
- * @return the value of the slider
- */
-int16_t lv_slider_get_value(const lv_obj_t * slider)
-{
-    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
-    return lv_bar_get_value(slider);
-}
-
 /**
  * Give the slider is being dragged or not
  * @param slider pointer to a slider object
@@ -168,7 +155,7 @@ static lv_design_res_t lv_slider_design(lv_obj_t * slider, const lv_area_t * cli
 
         /*The ancestor design function will draw the background and the indicator.
          * It also sets ext->bar.indic_area*/
-        ancestor_design_f(slider, clip_area, mode);
+        ancestor_design(slider, clip_area, mode);
 
         lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
         lv_bidi_dir_t base_dir = lv_obj_get_base_dir(slider);
@@ -231,7 +218,7 @@ static lv_design_res_t lv_slider_design(lv_obj_t * slider, const lv_area_t * cli
     }
     /*Post draw when the children are drawn*/
     else if(mode == LV_DESIGN_DRAW_POST) {
-        return ancestor_design_f(slider, clip_area, mode);
+        return ancestor_design(slider, clip_area, mode);
     }
 
     return LV_DESIGN_RES_OK;
@@ -258,7 +245,7 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(slider, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_slider_type_t type = lv_slider_get_type(slider);
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
@@ -334,10 +321,10 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
         lv_coord_t w = lv_obj_get_width(slider);
         lv_coord_t h = lv_obj_get_height(slider);
 
-        lv_style_int_t bg_left = lv_obj_get_style_pad_left(slider,   LV_SLIDER_PART_BG);
-        lv_style_int_t bg_right = lv_obj_get_style_pad_right(slider,  LV_SLIDER_PART_BG);
-        lv_style_int_t bg_top = lv_obj_get_style_pad_top(slider,    LV_SLIDER_PART_BG);
-        lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(slider, LV_SLIDER_PART_BG);
+        lv_style_int_t bg_left = lv_obj_get_style_pad_left(slider,   LV_SLIDER_PART_MAIN);
+        lv_style_int_t bg_right = lv_obj_get_style_pad_right(slider,  LV_SLIDER_PART_MAIN);
+        lv_style_int_t bg_top = lv_obj_get_style_pad_top(slider,    LV_SLIDER_PART_MAIN);
+        lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(slider, LV_SLIDER_PART_MAIN);
 
         int32_t range = ext->bar.max_value - ext->bar.min_value;
         int16_t new_value = 0;
@@ -415,7 +402,7 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
         knob_size += LV_MATH_MAX(LV_MATH_MAX(knob_left, knob_right), LV_MATH_MAX(knob_bottom, knob_top));
         knob_size += 2;         /*For rounding error*/
 
-        knob_size += lv_obj_get_draw_rect_ext_pad_size(slider, LV_SLIDER_PART_KNOB);
+        knob_size += _lv_obj_get_draw_rect_ext_pad_size(slider, LV_SLIDER_PART_KNOB);
 
         /*Indic. size is handled by bar*/
         slider->ext_draw_pad = LV_MATH_MAX(slider->ext_draw_pad, knob_size);
@@ -438,7 +425,7 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
 #endif
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(slider, LV_SLIDER_PART_KNOB);
+        _lv_obj_reset_style_list_no_refr(slider, LV_SLIDER_PART_KNOB);
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
 #if LV_USE_GROUP
@@ -459,7 +446,7 @@ static lv_style_list_t * lv_slider_get_style(lv_obj_t * slider, uint8_t part)
     lv_style_list_t * style_dsc_p;
 
     switch(part) {
-        case LV_SLIDER_PART_BG:
+        case LV_SLIDER_PART_MAIN:
             style_dsc_p = &slider->style_list;
             break;
         case LV_SLIDER_PART_INDIC:
diff --git a/src/lv_widgets/lv_slider.h b/src/lv_widgets/lv_slider.h
index 9012bb4a5..07aa657d2 100644
--- a/src/lv_widgets/lv_slider.h
+++ b/src/lv_widgets/lv_slider.h
@@ -53,9 +53,10 @@ typedef struct {
 
 /** Built-in styles of slider*/
 enum {
-    LV_SLIDER_PART_BG, /** Slider background style. */
-    LV_SLIDER_PART_INDIC, /** Slider indicator (filled area) style. */
-    LV_SLIDER_PART_KNOB, /** Slider knob style. */
+    LV_SLIDER_PART_MAIN = LV_BAR_PART_MAIN, /** Slider background style. */
+    LV_SLIDER_PART_INDIC = LV_BAR_PART_INDIC, /** Slider indicator (filled area) style. */
+    LV_SLIDER_PART_KNOB = _LV_BAR_PART_VIRTUAL_LAST, /** Slider knob style. */
+    _LV_SLIDER_PART_VIRTUAL_LAST
 };
 
 /**********************
@@ -64,11 +65,12 @@ enum {
 
 /**
  * Create a slider objects
- * @param par pointer to an object, it will be the parent of the new slider
- * @param copy pointer to a slider object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new slider
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other slider to copy.
  * @return pointer to the created slider
  */
-lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy);
+lv_obj_t * lv_slider_create(lv_obj_t * parent, lv_obj_t * copy);
 
 /*=====================
  * Setter functions
@@ -142,7 +144,10 @@ static inline void lv_slider_set_type(lv_obj_t * slider, lv_slider_type_t type)
  * @param slider pointer to a slider object
  * @return the value of the main knob of the slider
  */
-int16_t lv_slider_get_value(const lv_obj_t * slider);
+static inline int16_t lv_slider_get_value(const lv_obj_t * slider)
+{
+    return lv_bar_get_value(slider);
+}
 
 /**
  * Get the value of the left knob of a slider
diff --git a/src/lv_widgets/lv_switch.c b/src/lv_widgets/lv_switch.c
index 9340f1efa..ec38c0ea6 100644
--- a/src/lv_widgets/lv_switch.c
+++ b/src/lv_widgets/lv_switch.c
@@ -55,16 +55,17 @@ static lv_design_cb_t ancestor_design;
 
 /**
  * Create a switch objects
- * @param par pointer to an object, it will be the parent of the new switch
- * @param copy pointer to a switch object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new switch
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other switch to copy.
  * @return pointer to the created switch
  */
-lv_obj_t * lv_switch_create(lv_obj_t * par, const lv_obj_t * copy)
+lv_obj_t * lv_switch_create(lv_obj_t * parent, const lv_obj_t * copy)
 {
     LV_LOG_TRACE("switch create started");
 
     /*Create the ancestor of switch*/
-    lv_obj_t * sw = lv_bar_create(par, copy);
+    lv_obj_t * sw = lv_bar_create(parent, copy);
     LV_ASSERT_MEM(sw);
 
     if(sw == NULL) return NULL;
@@ -88,21 +89,17 @@ lv_obj_t * lv_switch_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new switch switch*/
     if(copy == NULL) {
-        lv_obj_set_click(sw, true);
-        lv_obj_add_protect(sw, LV_PROTECT_PRESS_LOST);
+        lv_obj_add_flag(sw, LV_OBJ_FLAG_CLICKABLE);
         lv_obj_set_size(sw, LV_DPX(60), LV_DPX(35));
         lv_bar_set_range(sw, 0, 1);
 
         lv_theme_apply(sw, LV_THEME_SWITCH);
-    }
-    /*Copy an existing switch*/
-    else {
+    } else {
         lv_switch_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
 
         lv_style_list_copy(&ext->style_knob, &copy_ext->style_knob);
-        lv_obj_refresh_style(sw, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(sw, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
-
     /*Refresh the style with new signal function*/
 
     LV_LOG_INFO("switch created");
@@ -212,8 +209,8 @@ static lv_design_res_t lv_switch_design(lv_obj_t * sw, const lv_area_t * clip_ar
         lv_coord_t knob_size = objh;
         lv_area_t knob_area;
 
-        lv_style_int_t bg_left = lv_obj_get_style_pad_left(sw,   LV_SWITCH_PART_BG);
-        lv_style_int_t bg_right = lv_obj_get_style_pad_right(sw,  LV_SWITCH_PART_BG);
+        lv_style_int_t bg_left = lv_obj_get_style_pad_left(sw,   LV_SWITCH_PART_MAIN);
+        lv_style_int_t bg_right = lv_obj_get_style_pad_right(sw,  LV_SWITCH_PART_MAIN);
 
         lv_coord_t max_indic_w = objw - bg_left - bg_right;
         lv_coord_t act_indic_w = lv_area_get_width(&ext->bar.indic_area);
@@ -267,25 +264,23 @@ static lv_res_t lv_switch_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
 {
     lv_res_t res;
 
+    /* Include the ancient signal function */
+    res = ancestor_signal(sw, sign, param);
+    if(res != LV_RES_OK) return res;
+
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         info->result = lv_switch_get_style(sw, info->part);
         if(info->result != NULL) return LV_RES_OK;
         else return ancestor_signal(sw, sign, param);
     }
-
-    if(sign == LV_SIGNAL_GET_TYPE) {
+    else if(sign == LV_SIGNAL_GET_TYPE) {
         res = ancestor_signal(sw, sign, param);
         if(res != LV_RES_OK) return res;
-        return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(sw, sign, param);
-    if(res != LV_RES_OK) return res;
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(sw, LV_SWITCH_PART_KNOB);
+    else if(sign == LV_SIGNAL_CLEANUP) {
+        _lv_obj_reset_style_list_no_refr(sw, LV_SWITCH_PART_KNOB);
     }
     else if(sign == LV_SIGNAL_RELEASED) {
         if(lv_switch_get_state(sw)) lv_switch_off(sw, LV_ANIM_ON);
@@ -316,7 +311,7 @@ static lv_res_t lv_switch_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
         knob_size += LV_MATH_MAX(LV_MATH_MAX(knob_left, knob_right), LV_MATH_MAX(knob_bottom, knob_top));
         knob_size += 2;         /*For rounding error*/
 
-        knob_size += lv_obj_get_draw_rect_ext_pad_size(sw, LV_SWITCH_PART_KNOB);
+        knob_size += _lv_obj_get_draw_rect_ext_pad_size(sw, LV_SWITCH_PART_KNOB);
 
         /*Indic. size is handled by bar*/
         sw->ext_draw_pad = LV_MATH_MAX(sw->ext_draw_pad, knob_size);
@@ -339,7 +334,7 @@ static lv_style_list_t * lv_switch_get_style(lv_obj_t * sw, uint8_t part)
     lv_style_list_t * style_dsc_p;
 
     switch(part) {
-        case LV_SWITCH_PART_BG:
+        case LV_SWITCH_PART_MAIN:
             style_dsc_p = &sw->style_list;
             break;
         case LV_SWITCH_PART_INDIC:
diff --git a/src/lv_widgets/lv_switch.h b/src/lv_widgets/lv_switch.h
index 609e44fcc..8079b0fc3 100644
--- a/src/lv_widgets/lv_switch.h
+++ b/src/lv_widgets/lv_switch.h
@@ -19,10 +19,9 @@ extern "C" {
 
 /*Testing of dependencies*/
 #if LV_USE_SLIDER == 0
-#error "lv_sw: lv_slider is required. Enable it in lv_conf.h (LV_USE_SLIDER  1)"
+#error "lv_switch: lv_slider is required. Enable it in lv_conf.h (LV_USE_SLIDER  1)"
 #endif
 
-#include "../lv_core/lv_obj.h"
 #include "lv_bar.h"
 
 /*********************
@@ -44,7 +43,7 @@ typedef struct {
  * Switch parts.
  */
 enum {
-    LV_SWITCH_PART_BG = LV_BAR_PART_BG,                 /**< Switch background. */
+    LV_SWITCH_PART_MAIN = LV_BAR_PART_MAIN,                 /**< Switch background. */
     LV_SWITCH_PART_INDIC = LV_BAR_PART_INDIC,           /**< Switch fill area. */
     LV_SWITCH_PART_KNOB = _LV_BAR_PART_VIRTUAL_LAST,    /**< Switch knob. */
     _LV_SWITCH_PART_VIRTUAL_LAST
@@ -58,11 +57,12 @@ typedef uint8_t lv_switch_part_t;
 
 /**
  * Create a switch objects
- * @param par pointer to an object, it will be the parent of the new switch
- * @param copy pointer to a switch object, if not NULL then the new object will be copied from it
+ * @param parent pointer to an object, it will be the parent of the new switch
+ * @param copy DEPRECATED, will be removed in v9.
+ *             Pointer to an other switch to copy.
  * @return pointer to the created switch
  */
-lv_obj_t * lv_switch_create(lv_obj_t * par, const lv_obj_t * copy);
+lv_obj_t * lv_switch_create(lv_obj_t * parent, const lv_obj_t * copy);
 
 /*=====================
  * Setter functions

From 25691a4d941645f2331c1a89854c1221a7257af6 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 15 Sep 2020 15:38:18 +0200
Subject: [PATCH 34/84] rework checkbox now it has no real parts, the bullet
 and text are drawn on the fly

---
 src/lv_core/lv_grid.h             |   2 -
 src/lv_core/lv_indev.c            |   2 +-
 src/lv_core/lv_obj.c              |  15 ++-
 src/lv_core/lv_obj.h              |   9 +-
 src/lv_core/lv_obj_draw.c         |  20 +--
 src/lv_core/lv_obj_pos.c          |  24 +++-
 src/lv_core/lv_obj_pos.h          |   9 ++
 src/lv_core/lv_obj_scroll.c       |  46 +++++--
 src/lv_core/lv_obj_style.c        |  10 +-
 src/lv_themes/lv_theme.c          |   2 +-
 src/lv_themes/lv_theme_material.c |   3 +-
 src/lv_themes/lv_theme_mono.c     |   2 +-
 src/lv_themes/lv_theme_template.c |   2 +-
 src/lv_widgets/lv_checkbox.c      | 195 ++++++++++++++++++++++--------
 src/lv_widgets/lv_checkbox.h      |  46 +++----
 15 files changed, 253 insertions(+), 134 deletions(-)

diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index d2cf08c3b..4f3dfc907 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -143,8 +143,6 @@ void _lv_grid_full_refresh(lv_obj_t * cont);
 
 void lv_grid_item_refr_pos(lv_obj_t * item);
 
-bool _lv_obj_is_grid_item(lv_obj_t * obj);
-
 
 /**********************
  * GLOBAL VARIABLES
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 119fea2c2..788a3dda3 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -848,7 +848,7 @@ static void indev_proc_press(lv_indev_proc_t * proc)
     }
 
     /*Do not use disabled objects*/
-    if(indev_obj_act && (lv_obj_get_state(indev_obj_act, LV_OBJ_PART_MAIN) & LV_STATE_DISABLED)) {
+    if(indev_obj_act && (lv_obj_get_state(indev_obj_act) & LV_STATE_DISABLED)) {
         indev_obj_act = proc->types.pointer.act_obj;
     }
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 4496d0d0b..92a4f181c 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -185,7 +185,7 @@ void lv_deinit(void)
  *             Pointer to an other base object to copy.
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy)
+lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 {
     lv_obj_t * new_obj = NULL;
 
@@ -775,10 +775,9 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
             }
         }
 
-        if(cmp_res == _LV_STYLE_STATE_CMP_DIFF) _lv_obj_refresh_style(obj, part, LV_STYLE_PROP_ALL);
     }
-
-    if(cmp_res == _LV_STYLE_STATE_CMP_VISUAL_DIFF) lv_obj_invalidate(obj);
+    if(cmp_res == _LV_STYLE_STATE_CMP_DIFF) _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    else if(cmp_res == _LV_STYLE_STATE_CMP_VISUAL_DIFF) lv_obj_invalidate(obj);
 
 #endif
 
@@ -1292,7 +1291,7 @@ lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 #endif
 }
 
-lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part)
+lv_state_t lv_obj_get_state(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -1815,7 +1814,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         /*Go the checked state if enabled*/
         if(lv_indev_get_scroll_obj(param) == NULL && lv_obj_has_flag(obj, LV_OBJ_FLAG_CHECKABLE)) {
             uint32_t toggled = 0;
-            if(!(lv_obj_get_state(obj, LV_OBJ_PART_MAIN) & LV_STATE_CHECKED)) {
+            if(!(lv_obj_get_state(obj) & LV_STATE_CHECKED)) {
                 lv_obj_add_state(obj, LV_STATE_CHECKED);
                 toggled = 0;
             }
@@ -1880,8 +1879,8 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-        if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
-           (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
+        if(param && ((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
+                     (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj))))
         {
             _lv_grid_full_refresh(obj);
         }
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index c663a0b3a..d9467ba1d 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -126,10 +126,11 @@ enum {
     LV_SIGNAL_CHILD_CHG,         /**< Child was removed/added */
     LV_SIGNAL_COORD_CHG,         /**< Object coordinates/size have changed */
     LV_SIGNAL_STYLE_CHG,         /**< Object's style has changed */
-    LV_SIGNAL_BASE_DIR_CHG,      /**<The base dir has changed*/
+    LV_SIGNAL_BASE_DIR_CHG,      /**< The base dir has changed*/
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
     LV_SIGNAL_GET_TYPE,          /**< LVGL needs to retrieve the object's type */
-    LV_SIGNAL_GET_STYLE,         /**<Get the style of an object*/
+    LV_SIGNAL_GET_STYLE,         /**< Get the style of an object*/
+    LV_SIGNAL_GET_SELF_SIZE,     /**< If there are virtual content on the widget get it's size*/
 
     /*Input device related*/
     LV_SIGNAL_HIT_TEST,          /**< Advanced hit-testing */
@@ -313,7 +314,7 @@ void lv_deinit(void);
  *             Pointer to an other base object to copy.
  * @return pointer to the new object
  */
-lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy);
+lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy);
 
 /**
  * Delete 'obj' and all of its children
@@ -644,7 +645,7 @@ bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f);
 
 lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj);
 
-lv_state_t lv_obj_get_state(const lv_obj_t * obj, uint8_t part);
+lv_state_t lv_obj_get_state(const lv_obj_t * obj);
 
 /**
  * Get the signal function of an object
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index 272496dbb..8180fb3b8 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -402,16 +402,6 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
         return;
     }
 
-    lv_coord_t st = lv_obj_get_scroll_top(obj);
-    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
-    lv_coord_t sl = lv_obj_get_scroll_left(obj);
-    lv_coord_t sr = lv_obj_get_scroll_right(obj);
-
-    /*Return if too small content to scroll*/
-    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sr <= 0) {
-        return;
-    }
-
     /*If there is no indev scrolling this object but the moe is active return*/
     lv_indev_t * indev = lv_indev_get_next(NULL);
     if(sm == LV_SCROLL_MODE_ACTIVE) {
@@ -428,6 +418,16 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
         }
     }
 
+    lv_coord_t st = lv_obj_get_scroll_top(obj);
+    lv_coord_t sb = lv_obj_get_scroll_bottom(obj);
+    lv_coord_t sl = lv_obj_get_scroll_left(obj);
+    lv_coord_t sr = lv_obj_get_scroll_right(obj);
+
+    /*Return if too small content to scroll*/
+    if(sm == LV_SCROLL_MODE_AUTO && st <= 0  && sb <= 0 && sl <= 0  && sr <= 0) {
+        return;
+    }
+
     lv_coord_t end_space = lv_obj_get_style_scrollbar_space_end(obj, LV_OBJ_PART_MAIN);
     lv_coord_t side_space = lv_obj_get_style_scrollbar_space_side(obj, LV_OBJ_PART_MAIN);
     lv_coord_t tickness = lv_obj_get_style_scrollbar_tickness(obj, LV_OBJ_PART_MAIN);
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 0288ab13d..fe254608f 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -441,7 +441,7 @@ lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
 }
 
 /**
- * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
+ * Calculate the "auto size". It's `auto_size = max(gird_size, children_size, self_size)`
  * @param obj pointer to an object
  * @param w_out store the width here. NULL to not calculate width
  * @param h_out store the height here. NULL to not calculate height
@@ -473,16 +473,17 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
     if(w_out) {
         lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
         lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
-        children_w = lv_obj_get_width(obj) + scroll_right;
+        lv_coord_t scroll_left = lv_obj_get_scroll_left(obj);
+        children_w = lv_obj_get_width(obj) + scroll_right + scroll_left;
     }
 
     if(h_out) {
         lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
         lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
-        children_h = lv_obj_get_height(obj) + scroll_bottom;
+        lv_coord_t scroll_top = lv_obj_get_scroll_top(obj);
+        children_h = lv_obj_get_height(obj) + scroll_bottom + scroll_top ;
     }
 
-
     /*auto_size = max(gird_size, children_size)*/
     if(w_out) *w_out = LV_MATH_MAX(children_w, grid_w);
     if(h_out) *h_out = LV_MATH_MAX(children_h, grid_h);
@@ -585,6 +586,18 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
     return false;
 }
 
+/**
+ * Get the size of the virtual content on an object
+ * (E.g. some texts which are "just drawn" and there is not real object behind them)
+ * @param obj pointer to an object
+ * @param p store the result size here
+ */
+void _lv_obj_get_self_size(lv_obj_t * obj, lv_point_t * p)
+{
+    p->x = 0;
+    p->y = 0;
+    lv_signal_send(obj, LV_SIGNAL_GET_SELF_SIZE, p);
+}
 
 /**********************
  *   STATIC FUNCTIONS
@@ -613,7 +626,8 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     lv_area_t ori;
     lv_obj_get_coords(obj, &ori);
 
-    /*Set the length and height*/
+    /* Set the length and height
+     * Be sure the content is not scrolled in an invalid position on the new size*/
     obj->coords.y2 = obj->coords.y1 + h - 1;
     if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
         obj->coords.x1 = obj->coords.x2 - w + 1;
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
index 8dd4d94d2..d508c8154 100644
--- a/src/lv_core/lv_obj_pos.h
+++ b/src/lv_core/lv_obj_pos.h
@@ -230,6 +230,15 @@ void _lv_obj_move_children_by(struct _lv_obj_t * obj, lv_coord_t x_diff, lv_coor
  * @return true: grid item; false: not grid item
  */
 bool _lv_obj_is_grid_item(struct _lv_obj_t * obj);
+
+/**
+ * Get the size of the virtual content on an object
+ * (E.g. some texts which are "just drawn" and there is not real object behind them)
+ * @param obj pointer to an object
+ * @param p store the result size here
+ */
+void _lv_obj_get_self_size(lv_obj_t * obj, lv_point_t * p);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index db1b1df7b..17206b166 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -183,17 +183,26 @@ lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_coord_t y2 = LV_COORD_MIN;
+    lv_coord_t child_res = LV_COORD_MIN;
 
     lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child == NULL) return 0;
+    if(child) {
+        lv_coord_t y2 = LV_COORD_MIN;
+        while(child) {
+            y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
+        }
 
-    while(child) {
-        y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
-        child = lv_obj_get_child(obj, child);
+        child_res = y2;
     }
 
-    return y2 - (obj->coords.y2 - lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN));
+    lv_point_t self_size;
+    _lv_obj_get_self_size(obj, &self_size);
+    self_size.y += obj->coords.y1 + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) + obj->scroll.y;
+
+    lv_coord_t y_max = LV_MATH_MAX(child_res, self_size.y) - obj->coords.y2;
+
+    return y_max + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
 }
 
 /**
@@ -217,19 +226,30 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
  */
 lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 {
+    static uint32_t cnt = 0;
+    printf("scrl right: %d\n", cnt);
+    cnt++;
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_coord_t x2 = LV_COORD_MIN;
-
+    lv_coord_t child_res = LV_COORD_MIN;
     lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child == NULL) return 0;
+    if(child) {
+        lv_coord_t x2 = LV_COORD_MIN;
+        while(child) {
+            x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
+        }
+        child_res = x2;
 
-    while(child) {
-        x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
-        child = lv_obj_get_child(obj, child);
     }
 
-    return x2 - (obj->coords.x2 - lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN));
+    lv_point_t self_size;
+    _lv_obj_get_self_size(obj, &self_size);
+    self_size.x += obj->coords.x1 + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + obj->scroll.x;
+
+    lv_coord_t x_max = LV_MATH_MAX(child_res, self_size.x) - obj->coords.x2;
+
+    return x_max + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
 }
 
 /**********************
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index bc4d69bff..c3c7799b8 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -409,7 +409,7 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
         }
 #endif
 
-        lv_state_t state = lv_obj_get_state(parent, part);
+        lv_state_t state = lv_obj_get_state(parent);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
 
         res = _lv_style_list_get_int(list, prop, &value_act);
@@ -474,7 +474,7 @@ lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_
     while(parent) {
         lv_style_list_t * list = _lv_obj_get_style_list(parent, part);
 
-        lv_state_t state = lv_obj_get_state(parent, part);
+        lv_state_t state = lv_obj_get_state(parent);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
 
         res = _lv_style_list_get_color(list, prop, &value_act);
@@ -552,7 +552,7 @@ lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_prop
         }
 #endif
 
-        lv_state_t state = lv_obj_get_state(parent, part);
+        lv_state_t state = lv_obj_get_state(parent);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
 
         res = _lv_style_list_get_opa(list, prop, &value_act);
@@ -629,7 +629,7 @@ const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_
             }
         }
 #endif
-        lv_state_t state = lv_obj_get_state(parent, part);
+        lv_state_t state = lv_obj_get_state(parent);
         prop = (uint16_t)prop_ori + ((uint16_t)state << LV_STYLE_STATE_POS);
 
         res = _lv_style_list_get_ptr(list, prop, &value_act);
@@ -1279,7 +1279,7 @@ static _lv_style_state_cmp_t style_snapshot_compare(style_snapshot_t * shot1, st
     if(shot1->pad_inner != shot2->pad_inner) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_top != shot2->margin_top) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_bottom != shot2->margin_bottom) return _LV_STYLE_STATE_CMP_DIFF;
-    if(shot1->margin_left != shot2->margin_right) return _LV_STYLE_STATE_CMP_DIFF;
+    if(shot1->margin_left != shot2->margin_left) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_right != shot2->margin_right) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_top != shot2->margin_top) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->transform_width != shot2->transform_width) return _LV_STYLE_STATE_CMP_DIFF;
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index 08b7fc8d8..66a626bac 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -306,7 +306,7 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            _lv_obj_reset_style_list_no_refr(obj, LV_CHECKBOX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_CHECKBOX_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_CHECKBOX_PART_BULLET);
             break;
 #endif
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index ca6b3e460..4c73697df 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -645,6 +645,7 @@ static void checkbox_init(void)
     lv_style_set_pad_right(&styles->cb_bullet, LV_STATE_DEFAULT, LV_DPX(3));
     lv_style_set_pad_top(&styles->cb_bullet, LV_STATE_DEFAULT, LV_DPX(3));
     lv_style_set_pad_bottom(&styles->cb_bullet, LV_STATE_DEFAULT, LV_DPX(3));
+    lv_style_set_margin_right(&styles->cb_bullet, LV_STATE_DEFAULT, LV_DPX(6));
 #endif
 }
 
@@ -1107,7 +1108,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->cb_bg);
 
             list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index bf934c9f1..77c6f554e 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -717,7 +717,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->pad_small);
 
             list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index 8d3e87508..ff220e120 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -563,7 +563,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_MAIN);
 
             list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->bg);
diff --git a/src/lv_widgets/lv_checkbox.c b/src/lv_widgets/lv_checkbox.c
index 3f8ac3dc7..f800c6322 100644
--- a/src/lv_widgets/lv_checkbox.c
+++ b/src/lv_widgets/lv_checkbox.c
@@ -25,6 +25,7 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_checkbox_get_style(lv_obj_t * cb, uint8_t type);
 
@@ -32,6 +33,7 @@ static lv_style_list_t * lv_checkbox_get_style(lv_obj_t * cb, uint8_t type);
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
+static lv_design_cb_t ancestor_design;
 
 /**********************
  *      MACROS
@@ -52,11 +54,12 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
     LV_LOG_TRACE("check box create started");
 
     /*Create the ancestor basic object*/
-    lv_obj_t * cb = lv_btn_create(par, copy);
+    lv_obj_t * cb = lv_obj_create(par, copy);
     LV_ASSERT_MEM(cb);
     if(cb == NULL) return NULL;
 
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(cb);
+    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(cb);
 
     lv_checkbox_ext_t * ext = lv_obj_allocate_ext_attr(cb, sizeof(lv_checkbox_ext_t));
     LV_ASSERT_MEM(ext);
@@ -65,34 +68,33 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
         return NULL;
     }
 
-    ext->bullet = NULL;
-    ext->label  = NULL;
+    ext->static_txt = 1;
+    ext->text = "Check box";
+    lv_style_list_init(&ext->style_bullet);
 
     lv_obj_set_signal_cb(cb, lv_checkbox_signal);
+    lv_obj_set_design_cb(cb, lv_checkbox_design);
 
     /*Init the new checkbox object*/
     if(copy == NULL) {
-        ext->bullet = lv_obj_create(cb, NULL);
-        lv_obj_set_click(ext->bullet, false);
-
-        ext->label = lv_label_create(cb, NULL);
-
-        lv_checkbox_set_text(cb, "Check box");
-        lv_btn_set_layout(cb, LV_LAYOUT_ROW_MID);
-        lv_btn_set_fit(cb, LV_FIT_TIGHT);
-        lv_btn_set_checkable(cb, true);
-        lv_obj_add_protect(cb, LV_PROTECT_PRESS_LOST);
-
         lv_theme_apply(cb, LV_THEME_CHECKBOX);
+        lv_obj_add_flag(cb, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_set_size(cb, LV_SIZE_AUTO, LV_SIZE_AUTO);
 
     }
     else {
-        lv_checkbox_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->bullet            = lv_obj_create(cb, copy_ext->bullet);
-        ext->label             = lv_label_create(cb, copy_ext->label);
 
+        lv_checkbox_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
+        lv_style_list_copy(&ext->style_bullet, &copy_ext->style_bullet);
+
+        ext->static_txt = copy_ext->static_txt;
+        if(copy_ext->static_txt) ext->text = copy_ext->text;
+        else {
+            ext->text = lv_mem_alloc(strlen(copy_ext->text) + 1);
+            strcpy(ext->text, copy_ext->text);
+        }
         /*Refresh the style with new signal function*/
-        //        lv_obj_refresh_style(cb);
+        _lv_obj_refresh_style(cb, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("check box created");
@@ -115,7 +117,16 @@ void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
     LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
 
     lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    lv_label_set_text(ext->label, txt);
+    if(ext->static_txt) {
+        ext->static_txt = 0;
+        ext->text = NULL;
+    }
+
+    ext->text = lv_mem_realloc(ext->text, strlen(txt) + 1);
+    strcpy(ext->text, txt);
+
+    lv_signal_send(cb, LV_SIGNAL_CHILD_CHG, NULL);
+
 }
 
 /**
@@ -129,7 +140,13 @@ void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
     LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
 
     lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    lv_label_set_text_static(ext->label, txt);
+    if(ext->static_txt == 0)  {
+        ext->static_txt = 1;
+        lv_mem_free(ext->text);
+        ext->text = NULL;
+    }
+
+    ext->text = txt;
 }
 
 /*=====================
@@ -146,13 +163,85 @@ const char * lv_checkbox_get_text(const lv_obj_t * cb)
     LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
 
     lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    return lv_label_get_text(ext->label);
+    return ext->text;
 }
 
 /**********************
  *   STATIC FUNCTIONS
  **********************/
 
+/**
+ * Handle the drawing related tasks of the check box
+ * @param cb pointer to a check box object
+ * @param clip_area the object will be drawn only in this area
+ * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
+ *                                  (return 'true' if yes)
+ *             LV_DESIGN_DRAW: draw the object (always return 'true')
+ *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
+ * @param return an element of `lv_design_res_t`
+ */
+static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_area, lv_design_mode_t mode)
+{
+    /* A label never covers an area */
+    if(mode == LV_DESIGN_COVER_CHK)
+        return LV_DESIGN_RES_NOT_COVER;
+    else if(mode == LV_DESIGN_DRAW_MAIN) {
+        /*Draw the background*/
+        ancestor_design(cb, clip_area, mode);
+
+        lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+
+        const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
+        lv_style_int_t letter_sp = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
+        lv_style_int_t line_sp = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
+       lv_coord_t line_height = lv_font_get_line_height(font);
+
+        lv_coord_t bg_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t bg_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t bg_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t bg_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_MAIN);
+
+        lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomm = lv_obj_get_style_margin_bottom(cb, LV_CHECKBOX_PART_BULLET);
+
+        lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_BULLET);
+
+        lv_draw_rect_dsc_t bullet_dsc;
+        lv_draw_rect_dsc_init(&bullet_dsc);
+        lv_obj_init_draw_rect_dsc(cb, LV_CHECKBOX_PART_BULLET, &bullet_dsc);
+        lv_area_t bullet_area;
+        bullet_area.x1 = cb->coords.x1 + bg_leftp + bullet_leftm;
+        bullet_area.x2 = bullet_area.x1 + line_height + bullet_leftp + bullet_rightp;
+        bullet_area.y1 = cb->coords.y1 + bg_topp + bullet_topm;
+        bullet_area.y2 = bullet_area.y1 + line_height + bullet_topp + bullet_bottomp;
+
+        lv_draw_rect(&bullet_area, clip_area, &bullet_dsc);
+
+        lv_point_t text_size;
+        _lv_txt_get_size(&text_size, ext->text, font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_RECOLOR);
+
+        lv_coord_t y_ofs = (lv_area_get_height(&bullet_area) - line_height) / 2;    /*Align the text to the bullet's center line*/
+        lv_area_t text_area;
+        text_area.x1 = bullet_area.x2 + bullet_rightm;
+        text_area.x2 = text_area.x1 + text_size.x;
+        text_area.y1 = bullet_area.y1 + bg_topp + y_ofs;
+        text_area.y2 = text_area.y1 + text_size.y;
+
+        lv_draw_label_dsc_t label_dsc;
+        lv_draw_label_dsc_init(&label_dsc);
+        lv_obj_init_draw_label_dsc(cb, LV_CHECKBOX_PART_MAIN, &label_dsc);
+        lv_draw_label(&text_area, clip_area, &label_dsc, ext->text, NULL);
+    } else {
+        ancestor_design(cb, clip_area, mode);
+    }
+
+    return LV_DESIGN_RES_OK;
+}
 /**
  * Signal function of the check box
  * @param cb pointer to a check box object
@@ -162,44 +251,48 @@ const char * lv_checkbox_get_text(const lv_obj_t * cb)
  */
 static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
 {
+    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+
     lv_res_t res;
+    /* Include the ancient signal function */
+    res = ancestor_signal(cb, sign, param);
+    if(res != LV_RES_OK) return res;
+
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         info->result = lv_checkbox_get_style(cb, info->part);
         if(info->result != NULL) return LV_RES_OK;
         else return ancestor_signal(cb, sign, param);
     }
+    else if (sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if (sign == LV_SIGNAL_GET_SELF_SIZE) {
+        const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
+        lv_style_int_t letter_sp = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
+        lv_style_int_t line_sp = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
+        lv_point_t text_size;
+        _lv_txt_get_size(&text_size, ext->text, font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_RECOLOR);
 
-    /* Include the ancient signal function */
-    res = ancestor_signal(cb, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-
-    if(sign == LV_SIGNAL_STYLE_CHG) {
-        const lv_font_t * font = lv_obj_get_style_text_font(ext->label, LV_LABEL_PART_MAIN);
         lv_coord_t line_height = lv_font_get_line_height(font);
-        lv_coord_t leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_BULLET);
 
-        lv_obj_set_size(ext->bullet, line_height + leftp + rightp, line_height + topp + bottomp);
-        lv_obj_set_state(ext->bullet, lv_obj_get_state(cb, LV_CHECKBOX_PART_BG));
-    }
-    else if(sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST ||
-            sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS) {
-        lv_obj_set_state(ext->bullet, lv_obj_get_state(cb, LV_CHECKBOX_PART_BG));
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        char c = *((char *)param);
-        if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN || c == LV_KEY_LEFT || c == LV_KEY_UP) {
-            /*Follow the backgrounds state with the bullet*/
-            lv_obj_set_state(ext->bullet, lv_obj_get_state(cb, LV_CHECKBOX_PART_BG));
-        }
-#endif
+        lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomm = lv_obj_get_style_margin_bottom(cb, LV_CHECKBOX_PART_BULLET);
+
+        lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_BULLET);
+
+        lv_point_t bullet_size;
+        bullet_size.x = line_height + bullet_leftm + bullet_rightm + bullet_leftp + bullet_rightp;
+        bullet_size.y = line_height + bullet_topm + bullet_bottomm + bullet_topp + bullet_bottomp;
+
+        lv_point_t * size_res = param;
+        size_res->x = bullet_size.x + text_size.x;
+        size_res->y = LV_MATH_MAX(bullet_size.y, text_size.y);
     }
 
     return res;
@@ -212,11 +305,11 @@ static lv_style_list_t * lv_checkbox_get_style(lv_obj_t * cb, uint8_t type)
 
     lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
     switch(type) {
-        case LV_CHECKBOX_PART_BG:
+        case LV_CHECKBOX_PART_MAIN:
             style_dsc_p = &cb->style_list;
             break;
         case LV_CHECKBOX_PART_BULLET:
-            style_dsc_p = lv_obj_get_style_list(ext->bullet, LV_BTN_PART_MAIN);
+            style_dsc_p = &ext->style_bullet;
             break;
         default:
             style_dsc_p = NULL;
diff --git a/src/lv_widgets/lv_checkbox.h b/src/lv_widgets/lv_checkbox.h
index 7576a76d9..c1b24aa74 100644
--- a/src/lv_widgets/lv_checkbox.h
+++ b/src/lv_widgets/lv_checkbox.h
@@ -27,8 +27,6 @@ extern "C" {
 #endif
 
 #include "../lv_core/lv_obj.h"
-#include "lv_btn.h"
-#include "lv_label.h"
 
 /*********************
  *      DEFINES
@@ -43,13 +41,15 @@ typedef struct {
     /*No inherited ext, derived from the base object */
 
     /*New data for this widget */
-    lv_obj_t * text; /*Pointer to button*/
-    lv_obj_t * label;  /*Pointer to label*/
+    lv_style_list_t style_bullet;
+    char * text;              /*Pointer to button*/
+    uint32_t static_txt :1;
 } lv_checkbox_ext_t;
 
 /** Checkbox styles. */
 enum {
     LV_CHECKBOX_PART_MAIN = LV_OBJ_PART_MAIN,  /**< Style of object background. */
+    LV_CHECKBOX_PART_BULLET,                   /**< Style of the bullet */
     _LV_CHECKBOX_PART_VIRTUAL_LAST,
 };
 typedef uint8_t lv_checkbox_style_t;
@@ -74,7 +74,7 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy);
  * Set the text of a check box. `txt` will be copied and may be deallocated
  * after this function returns.
  * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
+ * @param txt the text of the check box.
  */
 void lv_checkbox_set_text(lv_obj_t * cb, const char * txt);
 
@@ -82,7 +82,7 @@ void lv_checkbox_set_text(lv_obj_t * cb, const char * txt);
  * Set the text of a check box. `txt` must not be deallocated during the life
  * of this checkbox.
  * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
+ * @param txt the text of the check box.
  */
 void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt);
 
@@ -93,27 +93,21 @@ void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt);
  */
 static inline void lv_checkbox_set_checked(lv_obj_t * cb, bool checked)
 {
-    lv_btn_set_state(cb, checked ? LV_BTN_STATE_CHECKED_RELEASED : LV_BTN_STATE_RELEASED);
+    if(checked) lv_obj_set_state(cb, LV_STATE_CHECKED);
+    else lv_obj_clear_state(cb, LV_STATE_CHECKED);
 }
 
 /**
  * Make the check box inactive (disabled)
  * @param cb pointer to a check box object
+ * @param dis true; make the checkbox disabled; false: make the chackbox active
  */
-static inline void lv_checkbox_set_disabled(lv_obj_t * cb)
+static inline void lv_checkbox_set_disabled(lv_obj_t * cb, bool dis)
 {
-    lv_btn_set_state(cb, LV_BTN_STATE_DISABLED);
+    if(dis) lv_obj_set_state(cb, LV_STATE_DISABLED);
+    else lv_obj_clear_state(cb, LV_STATE_DISABLED);
 }
 
-/**
- * Set the state of a check box
- * @param cb pointer to a check box object
- * @param state the new state of the check box (from lv_btn_state_t enum)
- */
-static inline void lv_checkbox_set_state(lv_obj_t * cb, lv_btn_state_t state)
-{
-    lv_btn_set_state(cb, state);
-}
 /*=====================
  * Getter functions
  *====================*/
@@ -132,7 +126,7 @@ const char * lv_checkbox_get_text(const lv_obj_t * cb);
  */
 static inline bool lv_checkbox_is_checked(const lv_obj_t * cb)
 {
-    return lv_btn_get_state(cb) == LV_BTN_STATE_RELEASED ? false : true;
+    return lv_obj_get_state(cb) & LV_STATE_CHECKED ? true : false;
 }
 
 /**
@@ -140,19 +134,9 @@ static inline bool lv_checkbox_is_checked(const lv_obj_t * cb)
  * @param cb pointer to a check box object
  * @return true: inactive; false: not inactive
  */
-static inline bool lv_checkbox_is_inactive(const lv_obj_t * cb)
+static inline bool lv_checkbox_is_disabled(const lv_obj_t * cb)
 {
-    return lv_btn_get_state(cb) == LV_BTN_STATE_DISABLED ? true : false;
-}
-
-/**
- * Get the current state of a check box
- * @param cb pointer to a check box object
- * @return the state of the check box (from lv_btn_state_t enum)
- */
-static inline lv_btn_state_t lv_checkbox_get_state(const lv_obj_t * cb)
-{
-    return lv_btn_get_state(cb);
+    return lv_obj_get_state(cb) & LV_STATE_DISABLED ? true : false;
 }
 
 /**********************

From 1b15a7b8752efc223a78c2ea2a7430178c4c78c5 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 16 Sep 2020 11:26:06 +0200
Subject: [PATCH 35/84] simplify checkbox and btnmatrix

---
 src/lv_core/lv_indev_scroll.c     |   4 +
 src/lv_core/lv_obj.c              |   7 +-
 src/lv_core/lv_obj.h              |   1 -
 src/lv_core/lv_obj_draw.c         |   2 +
 src/lv_core/lv_obj_pos.c          |  13 --
 src/lv_core/lv_obj_pos.h          |   8 -
 src/lv_core/lv_obj_scroll.c       |  16 +-
 src/lv_core/lv_obj_style.c        |   3 -
 src/lv_core/lv_obj_style.h        |   1 -
 src/lv_core/lv_style.h            |   9 +-
 src/lv_themes/lv_theme.c          |   2 +-
 src/lv_themes/lv_theme_material.c |  36 ++---
 src/lv_themes/lv_theme_mono.c     |  10 +-
 src/lv_themes/lv_theme_template.c |   4 +-
 src/lv_widgets/lv_bar.c           |  36 +----
 src/lv_widgets/lv_btnmatrix.c     | 235 +++++++++++++-----------------
 src/lv_widgets/lv_btnmatrix.h     |  34 ++---
 src/lv_widgets/lv_checkbox.c      | 127 +---------------
 src/lv_widgets/lv_checkbox.h      |  26 ++--
 19 files changed, 185 insertions(+), 389 deletions(-)

diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 9c34798d3..6a3e808fb 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -66,6 +66,10 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
          *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
          *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
         while(proc->types.pointer.scroll_obj) {
+            if(lv_obj_has_flag(proc->types.pointer.scroll_obj, LV_OBJ_FLAG_SCROLLABLE) == false) {
+                proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
+                continue;
+            }
 
             /*Decide if it's a horizontal or vertical scroll*/
             bool hor_en = false;
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 92a4f181c..04bb0453c 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -284,7 +284,11 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     /*Set attributes*/
     new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
     new_obj->scroll_dir  = LV_DIR_ALL;
-    new_obj->flags = LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SNAPABLE | LV_OBJ_FLAG_PRESS_LOCK | LV_OBJ_FLAG_CLICK_FOCUSABLE;
+    new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
+    new_obj->flags |= LV_OBJ_FLAG_SNAPABLE;
+    new_obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
+    new_obj->flags |= LV_OBJ_FLAG_CLICK_FOCUSABLE;
+    new_obj->flags |= LV_OBJ_FLAG_SCROLLABLE;
     if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
     new_obj->scroll.x = 0;
@@ -1890,6 +1894,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
 
+        /*If the changed children was a grid item refresh this objects grid*/
         if(obj->grid) {
             lv_obj_t * child = param;
             if(child) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index d9467ba1d..b32cb8047 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -130,7 +130,6 @@ enum {
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
     LV_SIGNAL_GET_TYPE,          /**< LVGL needs to retrieve the object's type */
     LV_SIGNAL_GET_STYLE,         /**< Get the style of an object*/
-    LV_SIGNAL_GET_SELF_SIZE,     /**< If there are virtual content on the widget get it's size*/
 
     /*Input device related*/
     LV_SIGNAL_HIT_TEST,          /**< Advanced hit-testing */
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index 8180fb3b8..f01f26770 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -397,6 +397,8 @@ void _lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
  */
 void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
 {
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLLABLE) == false) return;
+
     lv_scroll_dir_t sm = lv_obj_get_scroll_mode(obj);
     if(sm == LV_SCROLL_MODE_OFF) {
         return;
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index fe254608f..4516a8c96 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -586,19 +586,6 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
     return false;
 }
 
-/**
- * Get the size of the virtual content on an object
- * (E.g. some texts which are "just drawn" and there is not real object behind them)
- * @param obj pointer to an object
- * @param p store the result size here
- */
-void _lv_obj_get_self_size(lv_obj_t * obj, lv_point_t * p)
-{
-    p->x = 0;
-    p->y = 0;
-    lv_signal_send(obj, LV_SIGNAL_GET_SELF_SIZE, p);
-}
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
index d508c8154..fa763d5bc 100644
--- a/src/lv_core/lv_obj_pos.h
+++ b/src/lv_core/lv_obj_pos.h
@@ -231,14 +231,6 @@ void _lv_obj_move_children_by(struct _lv_obj_t * obj, lv_coord_t x_diff, lv_coor
  */
 bool _lv_obj_is_grid_item(struct _lv_obj_t * obj);
 
-/**
- * Get the size of the virtual content on an object
- * (E.g. some texts which are "just drawn" and there is not real object behind them)
- * @param obj pointer to an object
- * @param p store the result size here
- */
-void _lv_obj_get_self_size(lv_obj_t * obj, lv_point_t * p);
-
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 17206b166..bae5e6fe1 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -196,13 +196,7 @@ lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
         child_res = y2;
     }
 
-    lv_point_t self_size;
-    _lv_obj_get_self_size(obj, &self_size);
-    self_size.y += obj->coords.y1 + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) + obj->scroll.y;
-
-    lv_coord_t y_max = LV_MATH_MAX(child_res, self_size.y) - obj->coords.y2;
-
-    return y_max + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+    return child_res - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
 }
 
 /**
@@ -243,13 +237,7 @@ lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 
     }
 
-    lv_point_t self_size;
-    _lv_obj_get_self_size(obj, &self_size);
-    self_size.x += obj->coords.x1 + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + obj->scroll.x;
-
-    lv_coord_t x_max = LV_MATH_MAX(child_res, self_size.x) - obj->coords.x2;
-
-    return x_max + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    return child_res - obj->coords.x2 + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
 }
 
 /**********************
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index c3c7799b8..c01b0a8b6 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -815,7 +815,6 @@ void _lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t pro
         case LV_STYLE_PAD_BOTTOM:
         case LV_STYLE_PAD_LEFT:
         case LV_STYLE_PAD_RIGHT:
-        case LV_STYLE_PAD_INNER:
         case LV_STYLE_MARGIN_TOP:
         case LV_STYLE_MARGIN_BOTTOM:
         case LV_STYLE_MARGIN_LEFT:
@@ -1243,7 +1242,6 @@ static void style_snapshot(lv_obj_t * obj, uint8_t part, style_snapshot_t * shot
     shot->pad_bottom = lv_obj_get_style_pad_bottom(obj, part);
     shot->pad_right = lv_obj_get_style_pad_right(obj, part);
     shot->pad_left = lv_obj_get_style_pad_left(obj, part);
-    shot->pad_inner = lv_obj_get_style_pad_inner(obj, part);
     shot->margin_top = lv_obj_get_style_margin_top(obj, part);
     shot->margin_bottom = lv_obj_get_style_margin_bottom(obj, part);
     shot->margin_left = lv_obj_get_style_margin_left(obj, part);
@@ -1276,7 +1274,6 @@ static _lv_style_state_cmp_t style_snapshot_compare(style_snapshot_t * shot1, st
     if(shot1->pad_left != shot2->pad_right) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->pad_right != shot2->pad_right) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->pad_top != shot2->pad_top) return _LV_STYLE_STATE_CMP_DIFF;
-    if(shot1->pad_inner != shot2->pad_inner) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_top != shot2->margin_top) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_bottom != shot2->margin_bottom) return _LV_STYLE_STATE_CMP_DIFF;
     if(shot1->margin_left != shot2->margin_left) return _LV_STYLE_STATE_CMP_DIFF;
diff --git a/src/lv_core/lv_obj_style.h b/src/lv_core/lv_obj_style.h
index 6bc91481b..7eecbb97d 100644
--- a/src/lv_core/lv_obj_style.h
+++ b/src/lv_core/lv_obj_style.h
@@ -411,7 +411,6 @@ _LV_OBJ_STYLE_SET_GET_DECLARE(PAD_TOP, pad_top, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(PAD_BOTTOM, pad_bottom, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(PAD_LEFT, pad_left, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(PAD_RIGHT, pad_right, lv_style_int_t, _int, scalar)
-_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_INNER, pad_inner, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_TOP, margin_top, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_BOTTOM, margin_bottom, lv_style_int_t, _int, scalar)
 _LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_LEFT, margin_left, lv_style_int_t, _int, scalar)
diff --git a/src/lv_core/lv_style.h b/src/lv_core/lv_style.h
index 9d2954569..c72cf906f 100644
--- a/src/lv_core/lv_style.h
+++ b/src/lv_core/lv_style.h
@@ -110,11 +110,10 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_PAD_BOTTOM,         0x1, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_PAD_LEFT,           0x1, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_PAD_RIGHT,          0x1, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_PAD_INNER,          0x1, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_TOP,         0x1, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_BOTTOM,      0x1, LV_STYLE_ID_VALUE + 6, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_LEFT,        0x1, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_RIGHT,       0x1, LV_STYLE_ID_VALUE + 8, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_TOP,         0x1, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_BOTTOM,      0x1, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_LEFT,        0x1, LV_STYLE_ID_VALUE + 6, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_RIGHT,       0x1, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
 
     LV_STYLE_PROP_INIT(LV_STYLE_BG_BLEND_MODE,      0x2, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_BG_MAIN_STOP,       0x2, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index 66a626bac..ace6b8777 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -225,7 +225,7 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            _lv_obj_reset_style_list_no_refr(obj, LV_BTNMATRIX_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_BTNMATRIX_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_BTNMATRIX_PART_BTN);
             break;
 #endif
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 4c73697df..b5ff691e0 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -80,7 +80,6 @@ typedef struct {
     lv_style_t bg_click;
     lv_style_t bg_sec;
     lv_style_t btn;
-    lv_style_t pad_inner;
     lv_style_t pad_small;
 
 #if LV_USE_ARC
@@ -94,6 +93,10 @@ typedef struct {
     lv_style_t bar_indic;
 #endif
 
+#if LV_USE_BTNMATRIX
+    lv_style_t btnmatrix_btn;
+#endif
+
 #if LV_USE_CALENDAR
     lv_style_t calendar_date_nums, calendar_header, calendar_daynames;
 #endif
@@ -236,7 +239,6 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_top(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_bottom(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
-    lv_style_set_pad_inner(&styles->bg, LV_STATE_DEFAULT, PAD_DEF);
     lv_style_set_transition_time(&styles->bg, LV_STATE_DEFAULT, TRANSITION_TIME);
     lv_style_set_transition_prop_6(&styles->bg, LV_STATE_DEFAULT, LV_STYLE_BORDER_COLOR);
 
@@ -308,7 +310,6 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->btn, LV_STATE_DEFAULT, LV_DPX(40));
     lv_style_set_pad_top(&styles->btn, LV_STATE_DEFAULT, LV_DPX(15));
     lv_style_set_pad_bottom(&styles->btn, LV_STATE_DEFAULT, LV_DPX(15));
-    lv_style_set_pad_inner(&styles->btn, LV_STATE_DEFAULT, LV_DPX(20));
     lv_style_set_outline_width(&styles->btn, LV_STATE_DEFAULT, OUTLINE_WIDTH);
     lv_style_set_outline_opa(&styles->btn, LV_STATE_DEFAULT, LV_OPA_0);
     lv_style_set_outline_opa(&styles->btn, LV_STATE_FOCUSED, LV_OPA_50);
@@ -321,18 +322,12 @@ static void basic_init(void)
     lv_style_set_transition_delay(&styles->btn, LV_STATE_DEFAULT, TRANSITION_TIME);
     lv_style_set_transition_delay(&styles->btn, LV_STATE_PRESSED, 0);
 
-    style_init_reset(&styles->pad_inner);
-
-    lv_style_set_pad_inner(&styles->pad_inner, LV_STATE_DEFAULT,
-                           lv_disp_get_size_category(NULL) <= LV_DISP_MEDIUM_LIMIT ? LV_DPX(20) : LV_DPX(40));
-
     style_init_reset(&styles->pad_small);
     lv_style_int_t pad_small_value = lv_disp_get_size_category(NULL) <= LV_DISP_MEDIUM_LIMIT ? LV_DPX(10) : LV_DPX(20);
     lv_style_set_pad_left(&styles->pad_small, LV_STATE_DEFAULT,  pad_small_value);
     lv_style_set_pad_right(&styles->pad_small, LV_STATE_DEFAULT, pad_small_value);
     lv_style_set_pad_top(&styles->pad_small, LV_STATE_DEFAULT,  pad_small_value);
     lv_style_set_pad_bottom(&styles->pad_small, LV_STATE_DEFAULT, pad_small_value);
-    lv_style_set_pad_inner(&styles->pad_small, LV_STATE_DEFAULT, pad_small_value);
 }
 
 static void cont_init(void)
@@ -349,6 +344,14 @@ static void btn_init(void)
 #endif
 }
 
+static void btnmatrix_init(void)
+{
+#if LV_USE_BTNMATRIX != 0
+    style_init_reset(&styles->btnmatrix_btn);
+    lv_style_set_margin_all(&styles->btnmatrix_btn, LV_STATE_DEFAULT, LV_DPX(10));
+#endif
+}
+
 static void label_init(void)
 {
 #if LV_USE_LABEL != 0
@@ -623,12 +626,14 @@ static void checkbox_init(void)
 #if LV_USE_CHECKBOX != 0
     style_init_reset(&styles->cb_bg);
     lv_style_set_radius(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(4));
-    lv_style_set_pad_inner(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(10));
+    lv_style_set_pad_left(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(30));
+    lv_style_set_pad_top(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(3));
+    lv_style_set_pad_bottom(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(3));
     lv_style_set_outline_color(&styles->cb_bg, LV_STATE_DEFAULT, theme.color_primary);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_DEFAULT, LV_OPA_TRANSP);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_FOCUSED, LV_OPA_50);
     lv_style_set_outline_width(&styles->cb_bg, LV_STATE_DEFAULT, OUTLINE_WIDTH);
-    lv_style_set_outline_pad(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(10));
+    lv_style_set_outline_pad(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(6));
     lv_style_set_transition_time(&styles->cb_bg, LV_STATE_DEFAULT, TRANSITION_TIME);
     lv_style_set_transition_prop_6(&styles->cb_bg, LV_STATE_DEFAULT, LV_STYLE_OUTLINE_OPA);
 
@@ -649,10 +654,6 @@ static void checkbox_init(void)
 #endif
 }
 
-static void btnmatrix_init(void)
-{
-}
-
 static void keyboard_init(void)
 {
 #if LV_USE_KEYBOARD
@@ -927,6 +928,7 @@ lv_theme_t * lv_theme_material_init(lv_color_t color_primary, lv_color_t color_s
     basic_init();
     cont_init();
     btn_init();
+    btnmatrix_init();
     label_init();
     bar_init();
     img_init();
@@ -942,7 +944,6 @@ lv_theme_t * lv_theme_material_init(lv_color_t color_primary, lv_color_t color_s
     calendar_init();
     cpicker_init();
     checkbox_init();
-    btnmatrix_init();
     keyboard_init();
     msgbox_init();
     page_init();
@@ -996,13 +997,14 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
             list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
+            _lv_style_list_add_style(list, &styles->btnmatrix_btn);
             break;
 #endif
 
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index 77c6f554e..6ddd50c1d 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -37,7 +37,6 @@ typedef struct {
     lv_style_t pad_none;
     lv_style_t pad_normal;
     lv_style_t pad_small;
-    lv_style_t pad_inner;
     lv_style_t txt_underline;
 
 #if LV_USE_ARC
@@ -137,7 +136,6 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_top(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_bottom(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
-    lv_style_set_pad_inner(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
 
     style_init_reset(&styles->clip_corner);
     lv_style_set_clip_corner(&styles->clip_corner, LV_STATE_DEFAULT, true);
@@ -190,24 +188,18 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->pad_none, LV_STATE_DEFAULT, 0);
     lv_style_set_pad_top(&styles->pad_none, LV_STATE_DEFAULT, 0);
     lv_style_set_pad_bottom(&styles->pad_none, LV_STATE_DEFAULT, 0);
-    lv_style_set_pad_inner(&styles->pad_none, LV_STATE_DEFAULT, 0);
 
     style_init_reset(&styles->pad_normal);
     lv_style_set_pad_left(&styles->pad_normal, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_right(&styles->pad_normal, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_top(&styles->pad_normal, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_bottom(&styles->pad_normal, LV_STATE_DEFAULT, LV_DPI / 10);
-    lv_style_set_pad_inner(&styles->pad_normal, LV_STATE_DEFAULT, LV_DPI / 10);
 
     style_init_reset(&styles->pad_small);
     lv_style_set_pad_left(&styles->pad_small, LV_STATE_DEFAULT, LV_DPI / 20);
     lv_style_set_pad_right(&styles->pad_small, LV_STATE_DEFAULT, LV_DPI / 20);
     lv_style_set_pad_top(&styles->pad_small, LV_STATE_DEFAULT, LV_DPI / 20);
     lv_style_set_pad_bottom(&styles->pad_small, LV_STATE_DEFAULT, LV_DPI / 20);
-    lv_style_set_pad_inner(&styles->pad_small, LV_STATE_DEFAULT, LV_DPI / 20);
-
-    style_init_reset(&styles->pad_inner);
-    lv_style_set_pad_inner(&styles->pad_inner, LV_STATE_DEFAULT, LV_DPI / 15);
 
     style_init_reset(&styles->txt_underline);
     lv_style_set_text_decor(&styles->txt_underline, LV_STATE_FOCUSED, LV_TEXT_DECOR_UNDERLINE);
@@ -590,7 +582,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
             list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index ff220e120..606a5f703 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -75,7 +75,6 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_top(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
     lv_style_set_pad_bottom(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
-    lv_style_set_pad_inner(&styles->bg, LV_STATE_DEFAULT, LV_DPI / 10);
 
     style_init_reset(&styles->btn);
     lv_style_set_bg_color(&styles->btn, LV_STATE_PRESSED, lv_color_hex3(0xccc));
@@ -108,7 +107,6 @@ static void basic_init(void)
     lv_style_set_pad_right(&styles->tight, LV_STATE_DEFAULT, 0);
     lv_style_set_pad_top(&styles->tight, LV_STATE_DEFAULT, 0);
     lv_style_set_pad_bottom(&styles->tight, LV_STATE_DEFAULT, 0);
-    lv_style_set_pad_inner(&styles->tight, LV_STATE_DEFAULT, 0);
 }
 
 static void arc_init(void)
@@ -439,7 +437,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
             list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
diff --git a/src/lv_widgets/lv_bar.c b/src/lv_widgets/lv_bar.c
index b08e409b1..4db6d3499 100644
--- a/src/lv_widgets/lv_bar.c
+++ b/src/lv_widgets/lv_bar.c
@@ -42,7 +42,6 @@ static lv_design_res_t lv_bar_design(lv_obj_t * bar, const lv_area_t * clip_area
 static lv_res_t lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_bar_get_style(lv_obj_t * bar, uint8_t part);
 
-static void draw_bg(lv_obj_t * bar, const lv_area_t * clip_area);
 static void draw_indic(lv_obj_t * bar, const lv_area_t * clip_area);
 
 #if LV_USE_ANIMATION
@@ -112,6 +111,7 @@ lv_obj_t * lv_bar_create(lv_obj_t * parent, lv_obj_t * copy)
 
     if(copy == NULL) {
         lv_obj_clear_flag(bar, LV_OBJ_FLAG_CHECKABLE);
+        lv_obj_clear_flag(bar, LV_OBJ_FLAG_SCROLLABLE);
         lv_obj_set_size(bar, LV_DPI * 2, LV_DPI / 10);
         lv_bar_set_value(bar, ext->cur_value, false);
 
@@ -370,7 +370,8 @@ static lv_design_res_t lv_bar_design(lv_obj_t * bar, const lv_area_t * clip_area
         return ancestor_design(bar, clip_area, mode);
     }
     else if(mode == LV_DESIGN_DRAW_MAIN) {
-        draw_bg(bar, clip_area);
+//        draw_bg(bar, clip_area);
+        ancestor_design(bar, clip_area, mode);
         draw_indic(bar, clip_area);
 
         /*Get the value and draw it after the indicator*/
@@ -385,40 +386,11 @@ static lv_design_res_t lv_bar_design(lv_obj_t * bar, const lv_area_t * clip_area
         lv_draw_rect(&bar->coords, clip_area, &draw_dsc);
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
-        /*If the border is drawn later disable loading other properties*/
-        if(lv_obj_get_style_border_post(bar, LV_OBJ_PART_MAIN)) {
-            lv_draw_rect_dsc_t draw_dsc;
-            lv_draw_rect_dsc_init(&draw_dsc);
-            draw_dsc.bg_opa = LV_OPA_TRANSP;
-            draw_dsc.pattern_opa = LV_OPA_TRANSP;
-            draw_dsc.outline_opa = LV_OPA_TRANSP;
-            draw_dsc.shadow_opa = LV_OPA_TRANSP;
-            draw_dsc.value_opa = LV_OPA_TRANSP;
-            lv_obj_init_draw_rect_dsc(bar, LV_OBJ_PART_MAIN, &draw_dsc);
-
-            lv_draw_rect(&bar->coords, clip_area, &draw_dsc);
-        }
+        ancestor_design(bar, clip_area, mode);
     }
     return LV_DESIGN_RES_OK;
 }
 
-static void draw_bg(lv_obj_t * bar, const lv_area_t * clip_area)
-{
-    /*Simply draw the background*/
-    lv_draw_rect_dsc_t draw_dsc;
-    lv_draw_rect_dsc_init(&draw_dsc);
-    /*If the border is drawn later disable loading its properties*/
-    if(lv_obj_get_style_border_post(bar, LV_BAR_PART_MAIN)) {
-        draw_dsc.border_opa = LV_OPA_TRANSP;
-    }
-
-    /*value will be drawn later*/
-    draw_dsc.value_opa = LV_OPA_TRANSP;
-    lv_obj_init_draw_rect_dsc(bar, LV_BAR_PART_MAIN, &draw_dsc);
-    lv_draw_rect(&bar->coords, clip_area, &draw_dsc);
-
-}
-
 static void draw_indic(lv_obj_t * bar, const lv_area_t * clip_area)
 {
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
diff --git a/src/lv_widgets/lv_btnmatrix.c b/src/lv_widgets/lv_btnmatrix.c
index d4a4a5c59..4ef632efb 100644
--- a/src/lv_widgets/lv_btnmatrix.c
+++ b/src/lv_widgets/lv_btnmatrix.c
@@ -39,12 +39,12 @@ static bool button_is_repeat_disabled(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_inactive(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_click_trig(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_tgl_enabled(lv_btnmatrix_ctrl_t ctrl_bits);
-static bool button_get_tgl_state(lv_btnmatrix_ctrl_t ctrl_bits);
+static bool button_get_checked(lv_btnmatrix_ctrl_t ctrl_bits);
 static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p);
 static void allocate_btn_areas_and_controls(const lv_obj_t * btnm, const char ** map);
 static void invalidate_button_area(const lv_obj_t * btnm, uint16_t btn_idx);
 static bool maps_are_identical(const char ** map1, const char ** map2);
-static void make_one_button_toggled(lv_obj_t * btnm, uint16_t btn_idx);
+static void make_one_button_checked(lv_obj_t * btnm, uint16_t btn_idx);
 
 /**********************
  *  STATIC VARIABLES
@@ -140,17 +140,6 @@ void lv_btnmatrix_set_map(lv_obj_t * btnm, const char * map[])
     LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
     LV_ASSERT_NULL(map);
 
-    /*
-     * lv_btnmatrix_set_map is called on receipt of signals such as
-     * LV_SIGNAL_CORD_CHG regardless of whether the map has changed (e.g.
-     * calling lv_obj_align on the map will trigger this).
-     *
-     * We check if the map has changed here to avoid overwriting changes made
-     * to hidden/longpress/disabled states after the map was originally set.
-     *
-     * TODO: separate all map set/allocation from layout code below and skip
-     * set/allocation when map hasn't changed.
-     */
     lv_btnmatrix_ext_t * ext = lv_obj_get_ext_attr(btnm);
     if(!maps_are_identical(ext->map_p, map)) {
 
@@ -159,102 +148,79 @@ void lv_btnmatrix_set_map(lv_obj_t * btnm, const char * map[])
     }
     ext->map_p = map;
 
-    /*Set size and positions of the buttons*/
-    lv_style_int_t left = lv_obj_get_style_pad_left(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t right = lv_obj_get_style_pad_right(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t top = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t inner = lv_obj_get_style_pad_inner(btnm, LV_BTNMATRIX_PART_BG);
+    lv_bidi_dir_t base_dir = lv_obj_get_base_dir(btnm);
 
-    lv_coord_t max_w            = lv_obj_get_width(btnm) - left - right;
-    lv_coord_t max_h            = lv_obj_get_height(btnm) - top - bottom;
-    lv_coord_t act_y            = top;
+    /*Set size and positions of the buttons*/
+    lv_style_int_t left = lv_obj_get_style_pad_left(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_style_int_t top = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_coord_t row_gap = LV_MATH_MAX(lv_obj_get_style_margin_top(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_bottom(btnm, LV_BTNMATRIX_PART_BTN));
+    lv_coord_t col_gap = LV_MATH_MAX(lv_obj_get_style_margin_left(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_right(btnm, LV_BTNMATRIX_PART_BTN));
+
+    lv_coord_t max_w            = lv_obj_get_width_fit(btnm);
+    lv_coord_t max_h            = lv_obj_get_height_fit(btnm);
 
     /*Count the lines to calculate button height*/
-    uint8_t line_cnt = 1;
-    uint8_t li;
-    for(li = 0; strlen(map[li]) != 0; li++) {
-        if(strcmp(map[li], "\n") == 0) line_cnt++;
+    uint8_t row_cnt = 1;
+    uint32_t i;
+    for(i = 0; strlen(map[i]) != 0; i++) {
+        if(strcmp(map[i], "\n") == 0) row_cnt++;
     }
 
-    lv_coord_t btn_h = max_h - ((line_cnt - 1) * inner);
-    btn_h            = btn_h / line_cnt;
-    btn_h--; /*-1 because e.g. height = 100 means 101 pixels (0..100)*/
+    /*Calculate the position of each row*/
+    lv_coord_t max_h_no_gap = max_h - (row_gap * (row_cnt - 1));
 
     /* Count the units and the buttons in a line
      * (A button can be 1,2,3... unit wide)*/
-    uint16_t unit_act_cnt;       /*Number of units currently put in a row*/
-    uint16_t i_tot          = 0; /*Act. index in the str map*/
-    uint16_t btn_i          = 0; /*Act. index of button areas*/
-    const char ** map_p_tmp = map;
+    uint32_t txt_tot_i = 0; /*Act. index in the str map*/
+    uint32_t btn_tot_i = 0; /*Act. index of button areas*/
+    const char ** map_row = map;
 
     /*Count the units and the buttons in a line*/
-    while(1) {
+    uint32_t row;
+    for(row = 0; row < row_cnt; row++) {
         uint16_t unit_cnt = 0;           /*Number of units in a row*/
         uint16_t btn_cnt = 0;            /*Number of buttons in a row*/
-        /*Count the buttons in a line*/
-        while(strcmp(map_p_tmp[btn_cnt], "\n") != 0 && strlen(map_p_tmp[btn_cnt]) != 0) { /*Check a line*/
-            unit_cnt += get_button_width(ext->ctrl_bits[btn_i + btn_cnt]);
+        /*Count the buttons and units in this row*/
+        while(strcmp(map_row[btn_cnt], "\n") != 0 && strlen(map_row[btn_cnt]) != '\0') {
+            unit_cnt += get_button_width(ext->ctrl_bits[btn_tot_i + btn_cnt]);
             btn_cnt++;
         }
 
-        /*Make sure the last row is at the bottom of 'btnm'*/
-        if(map_p_tmp[btn_cnt][0] == '\0') { /*Last row?*/
-            btn_h = lv_obj_get_height(btnm) - act_y - bottom - 1;
-        }
-
-        lv_bidi_dir_t base_dir = lv_obj_get_base_dir(btnm);
-
         /*Only deal with the non empty lines*/
-        if(btn_cnt != 0) {
-            /*Calculate the width of all units*/
-            lv_coord_t all_unit_w = max_w - ((unit_cnt - 1) * inner);
-
-            /*Set the button size and positions and set the texts*/
-            uint16_t i;
-            lv_coord_t act_x;
-
-            unit_act_cnt = 0;
-            for(i = 0; i < btn_cnt; i++) {
-                uint8_t btn_unit_w = get_button_width(ext->ctrl_bits[btn_i]);
-                /* one_unit_w = all_unit_w / unit_cnt
-                 * act_unit_w = one_unit_w * button_width
-                 * do this two operations but the multiply first to divide a greater number */
-                lv_coord_t act_unit_w = (all_unit_w * btn_unit_w) / unit_cnt + inner * (btn_unit_w - 1);
-                act_unit_w--; /*-1 because e.g. width = 100 means 101 pixels (0..100)*/
-
-                /*Always recalculate act_x because of rounding errors */
-                if(base_dir == LV_BIDI_DIR_RTL)  {
-                    act_x = (unit_act_cnt * all_unit_w) / unit_cnt + unit_act_cnt * inner;
-                    act_x = lv_obj_get_width(btnm) - right - act_x - act_unit_w - 1;
-                }
-                else {
-                    act_x = (unit_act_cnt * all_unit_w) / unit_cnt + unit_act_cnt * inner +
-                            left;
-                }
-                /* Set the button's area.
-                 * If inner padding is zero then use the prev. button x2 as x1 to avoid rounding
-                 * errors*/
-                if(btn_i != 0 && inner == 0 && ((act_x != left && base_dir != LV_BIDI_DIR_RTL) ||
-                                                (act_x + act_unit_w == max_w - right && base_dir == LV_BIDI_DIR_RTL))) {
-                    lv_area_set(&ext->button_areas[btn_i], ext->button_areas[btn_i - 1].x2, act_y, act_x + act_unit_w,
-                                act_y + btn_h);
-                }
-                else {
-                    lv_area_set(&ext->button_areas[btn_i], act_x, act_y, act_x + act_unit_w, act_y + btn_h);
-                }
-
-                unit_act_cnt += btn_unit_w;
-
-                i_tot++;
-                btn_i++;
-            }
+        if(btn_cnt == 0) {
+            map_row = &map_row[btn_cnt + 1];       /*Set the map to the next row*/
+            continue;
         }
-        act_y += btn_h + inner + 1;
 
-        if(strlen(map_p_tmp[btn_cnt]) == 0) break; /*Break on end of map*/
-        map_p_tmp = &map_p_tmp[btn_cnt + 1];       /*Set the map to the next line*/
-        i_tot++;                                   /*Skip the '\n'*/
+        lv_coord_t row_y1 = top + (max_h_no_gap * row) / row_cnt + row * row_gap;
+        lv_coord_t row_y2 = top + (max_h_no_gap * (row + 1)) / row_cnt + row * row_gap;
+
+
+        /*Set the button size and positions*/
+        lv_coord_t max_w_no_gap = max_w - (col_gap * (btn_cnt - 1));
+        uint32_t row_unit_cnt = 0;  /*The current unit position in the row*/
+        uint32_t btn;
+        for(btn = 0; btn < btn_cnt; btn++, btn_tot_i++, txt_tot_i++) {
+            uint32_t btn_u = get_button_width(ext->ctrl_bits[btn_tot_i]);
+
+            lv_coord_t btn_x1 = (max_w_no_gap * row_unit_cnt) / unit_cnt + btn * col_gap;
+            lv_coord_t btn_x2 = (max_w_no_gap * (row_unit_cnt + btn_u)) / unit_cnt + btn * col_gap;
+
+            /*If RTL start from the right*/
+            if(base_dir == LV_BIDI_DIR_RTL) {
+                lv_coord_t tmp = btn_x1;
+                btn_x1 = btn_x2;
+                btn_x2 = tmp;
+                btn_x1 = left + max_w - btn_x1;
+                btn_x2 = left + max_w - btn_x2;
+            }
+
+            lv_area_set(&ext->button_areas[btn_tot_i], btn_x1, row_y1, btn_x2, row_y2);
+
+            row_unit_cnt += btn_u;
+        }
+
+        map_row = &map_row[btn_cnt + 1];       /*Set the map to the next line*/
     }
 
     lv_obj_invalidate(btnm);
@@ -407,13 +373,13 @@ void lv_btnmatrix_set_btn_width(lv_obj_t * btnm, uint16_t btn_id, uint8_t width)
 }
 
 /**
- * Make the button matrix like a selector widget (only one button may be toggled at a time).
+ * Make the button matrix like a selector widget (only one button may be checked at a time).
  * `Checkable` must be enabled on the buttons you want to be selected with `lv_btnmatrix_set_ctrl` or
  * `lv_btnmatrix_set_btn_ctrl_all`.
- * @param btnm Button matrix object
- * @param one_chk Whether "one check" mode is enabled
+ * @param btnm pointer to a button matrix object
+ * @param one_chk whether "one check" mode is enabled
  */
-void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk)
+void lv_btnmatrix_set_one_checked(lv_obj_t * btnm, bool one_chk)
 {
     LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
 
@@ -421,7 +387,7 @@ void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk)
     ext->one_check     = one_chk;
 
     /*If more than one button is toggled only the first one should be*/
-    make_one_button_toggled(btnm, 0);
+    make_one_button_checked(btnm, 0);
 }
 
 /**
@@ -429,7 +395,7 @@ void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk)
  * @param btnm pointer to a btnmatrix object
  * @param align LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
  */
-void lv_btnmatrix_set_align(lv_obj_t * btnm, lv_label_align_t align)
+void lv_btnmatrix_set_text_align(lv_obj_t * btnm, lv_label_align_t align)
 {
     LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
 
@@ -573,7 +539,7 @@ bool lv_btnmatrix_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ct
  * @param btnm Button matrix object
  * @return whether "one check" mode is enabled
  */
-bool lv_btnmatrix_get_one_check(const lv_obj_t * btnm)
+bool lv_btnmatrix_get_one_checked(const lv_obj_t * btnm)
 {
     LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
 
@@ -674,8 +640,8 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
         bool chk_inited = false;
         bool disabled_inited = false;
 
-        lv_style_int_t padding_top = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_BG);
-        lv_style_int_t padding_bottom = lv_obj_get_style_pad_bottom(btnm, LV_BTNMATRIX_PART_BG);
+        lv_style_int_t padding_top = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_MAIN);
+        lv_style_int_t padding_bottom = lv_obj_get_style_pad_bottom(btnm, LV_BTNMATRIX_PART_MAIN);
 
         for(btn_i = 0; btn_i < ext->btn_cnt; btn_i++, txt_i++) {
             /*Search the next valid text in the map*/
@@ -699,7 +665,7 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
             lv_draw_rect_dsc_t * draw_rect_dsc_act;
             lv_draw_label_dsc_t * draw_label_dsc_act;
             lv_state_t btn_state = LV_STATE_DEFAULT;
-            if(button_get_tgl_state(ext->ctrl_bits[btn_i])) btn_state |= LV_STATE_CHECKED;
+            if(button_get_checked(ext->ctrl_bits[btn_i])) btn_state |= LV_STATE_CHECKED;
             if(button_is_inactive(ext->ctrl_bits[btn_i])) btn_state |= LV_STATE_DISABLED;
             if(btn_i == ext->btn_id_pr) btn_state |= LV_STATE_PRESSED;
             if(btn_i == ext->btn_id_focused) {
@@ -830,12 +796,12 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
     /* Include the ancient signal function */
     res = ancestor_signal(btnm, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_btnmatrix_ext_t * ext = lv_obj_get_ext_attr(btnm);
     lv_point_t p;
     if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(btnm, LV_BTNMATRIX_PART_BTN);
+        _lv_obj_reset_style_list_no_refr(btnm, LV_BTNMATRIX_PART_BTN);
         lv_mem_free(ext->button_areas);
         lv_mem_free(ext->ctrl_bits);
     }
@@ -843,7 +809,9 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
         lv_btnmatrix_set_map(btnm, ext->map_p);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(lv_obj_get_width(btnm) != lv_area_get_width(param) || lv_obj_get_height(btnm) != lv_area_get_height(param)) {
+        if(param &&
+           (lv_obj_get_width(btnm) != lv_area_get_width(param) || lv_obj_get_height(btnm) != lv_area_get_height(param)))
+        {
             lv_btnmatrix_set_map(btnm, ext->map_p);
         }
     }
@@ -920,13 +888,13 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             /*Toggle the button if enabled*/
             if(button_is_tgl_enabled(ext->ctrl_bits[ext->btn_id_pr]) &&
                !button_is_inactive(ext->ctrl_bits[ext->btn_id_pr])) {
-                if(button_get_tgl_state(ext->ctrl_bits[ext->btn_id_pr]) && !ext->one_check) {
-                    ext->ctrl_bits[ext->btn_id_pr] &= (~LV_BTNMATRIX_CTRL_CHECK_STATE);
+                if(button_get_checked(ext->ctrl_bits[ext->btn_id_pr]) && !ext->one_check) {
+                    ext->ctrl_bits[ext->btn_id_pr] &= (~LV_BTNMATRIX_CTRL_CHECKED);
                 }
                 else {
-                    ext->ctrl_bits[ext->btn_id_pr] |= LV_BTNMATRIX_CTRL_CHECK_STATE;
+                    ext->ctrl_bits[ext->btn_id_pr] |= LV_BTNMATRIX_CTRL_CHECKED;
                 }
-                if(ext->one_check) make_one_button_toggled(btnm, ext->btn_id_pr);
+                if(ext->one_check) make_one_button_checked(btnm, ext->btn_id_pr);
             }
 
             /*Invalidate to old pressed area*/;
@@ -1018,7 +986,8 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             lv_obj_invalidate(btnm);
         }
         else if(c == LV_KEY_DOWN) {
-            lv_style_int_t pad_inner = lv_obj_get_style_pad_inner(btnm, LV_BTNMATRIX_PART_BG);
+            lv_coord_t col_gap = LV_MATH_MAX(lv_obj_get_style_margin_left(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_right(btnm, LV_BTNMATRIX_PART_BTN));
+
             /*Find the area below the the current*/
             if(ext->btn_id_focused == LV_BTNMATRIX_BTN_NONE) {
                 ext->btn_id_focused = 0;
@@ -1031,7 +1000,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
                 for(area_below = ext->btn_id_focused; area_below < ext->btn_cnt; area_below++) {
                     if(ext->button_areas[area_below].y1 > ext->button_areas[ext->btn_id_focused].y1 &&
                        pr_center >= ext->button_areas[area_below].x1 &&
-                       pr_center <= ext->button_areas[area_below].x2 + pad_inner &&
+                       pr_center <= ext->button_areas[area_below].x2 + col_gap &&
                        button_is_inactive(ext->ctrl_bits[area_below]) == false &&
                        button_is_hidden(ext->ctrl_bits[area_below]) == false) {
                         break;
@@ -1044,7 +1013,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             lv_obj_invalidate(btnm);
         }
         else if(c == LV_KEY_UP) {
-            lv_style_int_t pad_inner = lv_obj_get_style_pad_inner(btnm, LV_BTNMATRIX_PART_BG);
+            lv_coord_t col_gap = LV_MATH_MAX(lv_obj_get_style_margin_left(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_right(btnm, LV_BTNMATRIX_PART_BTN));
             /*Find the area below the the current*/
             if(ext->btn_id_focused == LV_BTNMATRIX_BTN_NONE) {
                 ext->btn_id_focused = 0;
@@ -1056,7 +1025,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
 
                 for(area_above = ext->btn_id_focused; area_above >= 0; area_above--) {
                     if(ext->button_areas[area_above].y1 < ext->button_areas[ext->btn_id_focused].y1 &&
-                       pr_center >= ext->button_areas[area_above].x1 - pad_inner &&
+                       pr_center >= ext->button_areas[area_above].x1 - col_gap &&
                        pr_center <= ext->button_areas[area_above].x2 &&
                        button_is_inactive(ext->ctrl_bits[area_above]) == false &&
                        button_is_hidden(ext->ctrl_bits[area_above]) == false) {
@@ -1094,7 +1063,7 @@ static lv_style_list_t * lv_btnmatrix_get_style(lv_obj_t * btnm, uint8_t part)
     lv_style_list_t * style_dsc_p;
 
     switch(part) {
-        case LV_BTNMATRIX_PART_BG:
+        case LV_BTNMATRIX_PART_MAIN:
             style_dsc_p = &btnm->style_list;
             break;
         case LV_BTNMATRIX_PART_BTN:
@@ -1182,9 +1151,9 @@ static bool button_is_tgl_enabled(lv_btnmatrix_ctrl_t ctrl_bits)
     return (ctrl_bits & LV_BTNMATRIX_CTRL_CHECKABLE) ? true : false;
 }
 
-static bool button_get_tgl_state(lv_btnmatrix_ctrl_t ctrl_bits)
+static bool button_get_checked(lv_btnmatrix_ctrl_t ctrl_bits)
 {
-    return (ctrl_bits & LV_BTNMATRIX_CTRL_CHECK_STATE) ? true : false;
+    return (ctrl_bits & LV_BTNMATRIX_CTRL_CHECKED) ? true : false;
 }
 
 /**
@@ -1203,16 +1172,20 @@ static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
 
     lv_coord_t w = lv_obj_get_width(btnm);
     lv_coord_t h = lv_obj_get_height(btnm);
-    lv_style_int_t pleft = lv_obj_get_style_pad_left(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t pright = lv_obj_get_style_pad_right(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t ptop = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t pbottom = lv_obj_get_style_pad_bottom(btnm, LV_BTNMATRIX_PART_BG);
-    lv_style_int_t pinner = lv_obj_get_style_pad_inner(btnm, LV_BTNMATRIX_PART_BG);
+    lv_style_int_t pleft = lv_obj_get_style_pad_left(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_style_int_t pright = lv_obj_get_style_pad_right(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_style_int_t ptop = lv_obj_get_style_pad_top(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_style_int_t pbottom = lv_obj_get_style_pad_bottom(btnm, LV_BTNMATRIX_PART_MAIN);
+    lv_coord_t row_gap = LV_MATH_MAX(lv_obj_get_style_margin_top(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_bottom(btnm, LV_BTNMATRIX_PART_BTN));
+    lv_coord_t col_gap = LV_MATH_MAX(lv_obj_get_style_margin_left(btnm, LV_BTNMATRIX_PART_BTN), lv_obj_get_style_margin_right(btnm, LV_BTNMATRIX_PART_BTN));
 
-    /*Get the half inner padding. Button look larger with this value. (+1 for rounding error)*/
-    pinner = (pinner / 2) + 1 + (pinner & 1);
 
-    pinner = LV_MATH_MIN(pinner, BTN_EXTRA_CLICK_AREA_MAX);
+    /*Get the half gap. Button look larger with this value. (+1 for rounding error)*/
+    row_gap = (row_gap / 2) + 1 + (row_gap & 1);
+    col_gap = (col_gap / 2) + 1 + (col_gap & 1);
+
+    row_gap = LV_MATH_MIN(row_gap, BTN_EXTRA_CLICK_AREA_MAX);
+    col_gap = LV_MATH_MIN(col_gap, BTN_EXTRA_CLICK_AREA_MAX);
     pright = LV_MATH_MIN(pright, BTN_EXTRA_CLICK_AREA_MAX);
     ptop = LV_MATH_MIN(ptop, BTN_EXTRA_CLICK_AREA_MAX);
     pbottom = LV_MATH_MIN(pbottom, BTN_EXTRA_CLICK_AREA_MAX);
@@ -1220,18 +1193,18 @@ static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
     for(i = 0; i < ext->btn_cnt; i++) {
         lv_area_copy(&btn_area, &ext->button_areas[i]);
         if(btn_area.x1 <= pleft) btn_area.x1 += btnm_cords.x1 - LV_MATH_MIN(pleft, BTN_EXTRA_CLICK_AREA_MAX);
-        else btn_area.x1 += btnm_cords.x1 - pinner;
+        else btn_area.x1 += btnm_cords.x1 - col_gap;
 
         if(btn_area.y1 <= ptop) btn_area.y1 += btnm_cords.y1 - LV_MATH_MIN(ptop, BTN_EXTRA_CLICK_AREA_MAX);
-        else btn_area.y1 += btnm_cords.y1 - pinner;
+        else btn_area.y1 += btnm_cords.y1 - row_gap;
 
         if(btn_area.x2 >= w - pright - 2) btn_area.x2 += btnm_cords.x1 + LV_MATH_MIN(pright,
                                                                                          BTN_EXTRA_CLICK_AREA_MAX);  /*-2 for rounding error*/
-        else btn_area.x2 += btnm_cords.x1 + pinner;
+        else btn_area.x2 += btnm_cords.x1 + col_gap;
 
         if(btn_area.y2 >= h - pbottom - 2) btn_area.y2 += btnm_cords.y1 + LV_MATH_MIN(pbottom,
                                                                                           BTN_EXTRA_CLICK_AREA_MAX); /*-2 for rounding error*/
-        else btn_area.y2 += btnm_cords.y1 + pinner;
+        else btn_area.y2 += btnm_cords.y1 + row_gap;
 
         if(_lv_area_is_point_on(&btn_area, p, 0) != false) {
             break;
@@ -1288,14 +1261,14 @@ static bool maps_are_identical(const char ** map1, const char ** map2)
  * @param btnm Button matrix object
  * @param btn_idx Button that should remain toggled
  */
-static void make_one_button_toggled(lv_obj_t * btnm, uint16_t btn_idx)
+static void make_one_button_checked(lv_obj_t * btnm, uint16_t btn_idx)
 {
     /*Save whether the button was toggled*/
-    bool was_toggled = lv_btnmatrix_get_btn_ctrl(btnm, btn_idx, LV_BTNMATRIX_CTRL_CHECK_STATE);
+    bool was_toggled = lv_btnmatrix_get_btn_ctrl(btnm, btn_idx, LV_BTNMATRIX_CTRL_CHECKED);
 
-    lv_btnmatrix_clear_btn_ctrl_all(btnm, LV_BTNMATRIX_CTRL_CHECK_STATE);
+    lv_btnmatrix_clear_btn_ctrl_all(btnm, LV_BTNMATRIX_CTRL_CHECKED);
 
-    if(was_toggled) lv_btnmatrix_set_btn_ctrl(btnm, btn_idx, LV_BTNMATRIX_CTRL_CHECK_STATE);
+    if(was_toggled) lv_btnmatrix_set_btn_ctrl(btnm, btn_idx, LV_BTNMATRIX_CTRL_CHECKED);
 }
 
 #endif
diff --git a/src/lv_widgets/lv_btnmatrix.h b/src/lv_widgets/lv_btnmatrix.h
index c30a959f0..b2c332621 100644
--- a/src/lv_widgets/lv_btnmatrix.h
+++ b/src/lv_widgets/lv_btnmatrix.h
@@ -40,8 +40,8 @@ enum {
     LV_BTNMATRIX_CTRL_NO_REPEAT  = 0x0010, /**< Do not repeat press this button. */
     LV_BTNMATRIX_CTRL_DISABLED   = 0x0020, /**< Disable this button. */
     LV_BTNMATRIX_CTRL_CHECKABLE  = 0x0040, /**< Button *can* be toggled. */
-    LV_BTNMATRIX_CTRL_CHECK_STATE  = 0x0080, /**< Button is currently toggled (e.g. checked). */
-    LV_BTNMATRIX_CTRL_CLICK_TRIG = 0x0100, /**< 1: Send LV_EVENT_SELECTED on CLICK, 0: Send LV_EVENT_SELECTED on PRESS*/
+    LV_BTNMATRIX_CTRL_CHECKED    = 0x0080, /**< Button is currently toggled (e.g. checked). */
+    LV_BTNMATRIX_CTRL_CLICK_TRIG = 0x0100, /**< 1: Send LV_EVENT_VALUE_CHANGE on CLICK, 0: Send LV_EVENT_VALUE_CHANGE on PRESS*/
 };
 typedef uint16_t lv_btnmatrix_ctrl_t;
 
@@ -63,7 +63,7 @@ typedef struct {
 } lv_btnmatrix_ext_t;
 
 enum {
-    LV_BTNMATRIX_PART_BG,
+    LV_BTNMATRIX_PART_MAIN,
     LV_BTNMATRIX_PART_BTN,
 };
 typedef uint8_t lv_btnmatrix_part_t;
@@ -163,20 +163,20 @@ void lv_btnmatrix_clear_btn_ctrl_all(lv_obj_t * btnm, lv_btnmatrix_ctrl_t ctrl);
 void lv_btnmatrix_set_btn_width(lv_obj_t * btnm, uint16_t btn_id, uint8_t width);
 
 /**
- * Make the button matrix like a selector widget (only one button may be toggled at a time).
+ * Make the button matrix like a selector widget (only one button may be checked at a time).
  * `Checkable` must be enabled on the buttons you want to be selected with `lv_btnmatrix_set_ctrl` or
  * `lv_btnmatrix_set_btn_ctrl_all`.
- * @param btnm Button matrix object
- * @param one_chk Whether "one check" mode is enabled
+ * @param btnm pointer to a button matrix object
+ * @param one_chk whether "one check" mode is enabled
  */
-void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk);
+void lv_btnmatrix_set_one_checked(lv_obj_t * btnm, bool one_chk);
 
 /**
- * Set the align of the map text (left, right or center)
+ * Set the align of the texts (left, right or center)
  * @param btnm pointer to a btnmatrix object
  * @param align LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
  */
-void lv_btnmatrix_set_align(lv_obj_t * btnm, lv_label_align_t align);
+void lv_btnmatrix_set_text_align(lv_obj_t * btnm, lv_label_align_t align);
 
 /*=====================
  * Getter functions
@@ -204,14 +204,6 @@ bool lv_btnmatrix_get_recolor(const lv_obj_t * btnm);
  */
 uint16_t lv_btnmatrix_get_active_btn(const lv_obj_t * btnm);
 
-/**
- * Get the text of the lastly "activated" button by the user (pressed, released etc)
- * Useful in the the `event_cb`
- * @param btnm pointer to button matrix object
- * @return text of the last released button (NULL: if unset)
- */
-const char * lv_btnmatrix_get_active_btn_text(const lv_obj_t * btnm);
-
 /**
  * Get the focused button's index.
  * @param btnm pointer to button matrix object
@@ -232,18 +224,18 @@ const char * lv_btnmatrix_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id);
  * Get the whether a control value is enabled or disabled for button of a button matrix
  * @param btnm pointer to a button matrix object
  * @param btn_id the index a button not counting new line characters. (E.g. the return value of
- * lv_btnmatrix_get_pressed/released)
+ * lv_btnmatrix_get_active)
  * @param ctrl control values to check (ORed value can be used)
  * @return true: long press repeat is disabled; false: long press repeat enabled
  */
 bool lv_btnmatrix_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl);
 
 /**
- * Find whether "one toggle" mode is enabled.
+ * Find whether "one checked" mode is enabled.
  * @param btnm Button matrix object
- * @return whether "one toggle" mode is enabled
+ * @return whether "one checked" mode is enabled
  */
-bool lv_btnmatrix_get_one_check(const lv_obj_t * btnm);
+bool lv_btnmatrix_get_one_checked(const lv_obj_t * btnm);
 
 /**
  * Get the align attribute
diff --git a/src/lv_widgets/lv_checkbox.c b/src/lv_widgets/lv_checkbox.c
index f800c6322..f577633b4 100644
--- a/src/lv_widgets/lv_checkbox.c
+++ b/src/lv_widgets/lv_checkbox.c
@@ -54,7 +54,7 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
     LV_LOG_TRACE("check box create started");
 
     /*Create the ancestor basic object*/
-    lv_obj_t * cb = lv_obj_create(par, copy);
+    lv_obj_t * cb = lv_label_create(par, copy);
     LV_ASSERT_MEM(cb);
     if(cb == NULL) return NULL;
 
@@ -68,8 +68,6 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
         return NULL;
     }
 
-    ext->static_txt = 1;
-    ext->text = "Check box";
     lv_style_list_init(&ext->style_bullet);
 
     lv_obj_set_signal_cb(cb, lv_checkbox_signal);
@@ -77,9 +75,9 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new checkbox object*/
     if(copy == NULL) {
+        lv_label_set_text_static(cb, "Check box");
         lv_theme_apply(cb, LV_THEME_CHECKBOX);
         lv_obj_add_flag(cb, LV_OBJ_FLAG_CLICKABLE);
-        lv_obj_set_size(cb, LV_SIZE_AUTO, LV_SIZE_AUTO);
 
     }
     else {
@@ -87,12 +85,6 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_checkbox_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
         lv_style_list_copy(&ext->style_bullet, &copy_ext->style_bullet);
 
-        ext->static_txt = copy_ext->static_txt;
-        if(copy_ext->static_txt) ext->text = copy_ext->text;
-        else {
-            ext->text = lv_mem_alloc(strlen(copy_ext->text) + 1);
-            strcpy(ext->text, copy_ext->text);
-        }
         /*Refresh the style with new signal function*/
         _lv_obj_refresh_style(cb, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
@@ -106,66 +98,10 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
  * Setter functions
  *====================*/
 
-/**
- * Set the text of a check box. `txt` will be copied and may be deallocated
- * after this function returns.
- * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
- */
-void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
-{
-    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
-
-    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    if(ext->static_txt) {
-        ext->static_txt = 0;
-        ext->text = NULL;
-    }
-
-    ext->text = lv_mem_realloc(ext->text, strlen(txt) + 1);
-    strcpy(ext->text, txt);
-
-    lv_signal_send(cb, LV_SIGNAL_CHILD_CHG, NULL);
-
-}
-
-/**
- * Set the text of a check box. `txt` must not be deallocated during the life
- * of this checkbox.
- * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
- */
-void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
-{
-    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
-
-    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    if(ext->static_txt == 0)  {
-        ext->static_txt = 1;
-        lv_mem_free(ext->text);
-        ext->text = NULL;
-    }
-
-    ext->text = txt;
-}
-
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the text of a check box
- * @param cb pointer to check box object
- * @return pointer to the text of the check box
- */
-const char * lv_checkbox_get_text(const lv_obj_t * cb)
-{
-    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
-
-    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-    return ext->text;
-}
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -192,19 +128,12 @@ static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_
         lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
 
         const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
-        lv_style_int_t letter_sp = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
-        lv_style_int_t line_sp = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
-       lv_coord_t line_height = lv_font_get_line_height(font);
+        lv_coord_t line_height = lv_font_get_line_height(font);
 
-        lv_coord_t bg_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_MAIN);
-        lv_coord_t bg_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_MAIN);
         lv_coord_t bg_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_MAIN);
-        lv_coord_t bg_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_MAIN);
 
         lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
         lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_bottomm = lv_obj_get_style_margin_bottom(cb, LV_CHECKBOX_PART_BULLET);
 
         lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
         lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
@@ -215,27 +144,12 @@ static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_
         lv_draw_rect_dsc_init(&bullet_dsc);
         lv_obj_init_draw_rect_dsc(cb, LV_CHECKBOX_PART_BULLET, &bullet_dsc);
         lv_area_t bullet_area;
-        bullet_area.x1 = cb->coords.x1 + bg_leftp + bullet_leftm;
-        bullet_area.x2 = bullet_area.x1 + line_height + bullet_leftp + bullet_rightp;
-        bullet_area.y1 = cb->coords.y1 + bg_topp + bullet_topm;
-        bullet_area.y2 = bullet_area.y1 + line_height + bullet_topp + bullet_bottomp;
+        bullet_area.x1 = cb->coords.x1 + bullet_leftm;
+        bullet_area.x2 = bullet_area.x1 + line_height + bullet_leftp + bullet_rightp - 1;
+        bullet_area.y1 = cb->coords.y1 + bg_topp - bullet_topp + bullet_topm;
+        bullet_area.y2 = bullet_area.y1 + line_height + bullet_topp + bullet_bottomp - 1;
 
         lv_draw_rect(&bullet_area, clip_area, &bullet_dsc);
-
-        lv_point_t text_size;
-        _lv_txt_get_size(&text_size, ext->text, font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_RECOLOR);
-
-        lv_coord_t y_ofs = (lv_area_get_height(&bullet_area) - line_height) / 2;    /*Align the text to the bullet's center line*/
-        lv_area_t text_area;
-        text_area.x1 = bullet_area.x2 + bullet_rightm;
-        text_area.x2 = text_area.x1 + text_size.x;
-        text_area.y1 = bullet_area.y1 + bg_topp + y_ofs;
-        text_area.y2 = text_area.y1 + text_size.y;
-
-        lv_draw_label_dsc_t label_dsc;
-        lv_draw_label_dsc_init(&label_dsc);
-        lv_obj_init_draw_label_dsc(cb, LV_CHECKBOX_PART_MAIN, &label_dsc);
-        lv_draw_label(&text_area, clip_area, &label_dsc, ext->text, NULL);
     } else {
         ancestor_design(cb, clip_area, mode);
     }
@@ -267,33 +181,6 @@ static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param
     else if (sign == LV_SIGNAL_GET_TYPE) {
         return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
-    else if (sign == LV_SIGNAL_GET_SELF_SIZE) {
-        const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
-        lv_style_int_t letter_sp = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
-        lv_style_int_t line_sp = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
-        lv_point_t text_size;
-        _lv_txt_get_size(&text_size, ext->text, font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_RECOLOR);
-
-        lv_coord_t line_height = lv_font_get_line_height(font);
-
-        lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_bottomm = lv_obj_get_style_margin_bottom(cb, LV_CHECKBOX_PART_BULLET);
-
-        lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_BULLET);
-        lv_coord_t bullet_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_BULLET);
-
-        lv_point_t bullet_size;
-        bullet_size.x = line_height + bullet_leftm + bullet_rightm + bullet_leftp + bullet_rightp;
-        bullet_size.y = line_height + bullet_topm + bullet_bottomm + bullet_topp + bullet_bottomp;
-
-        lv_point_t * size_res = param;
-        size_res->x = bullet_size.x + text_size.x;
-        size_res->y = LV_MATH_MAX(bullet_size.y, text_size.y);
-    }
 
     return res;
 }
diff --git a/src/lv_widgets/lv_checkbox.h b/src/lv_widgets/lv_checkbox.h
index c1b24aa74..43753b845 100644
--- a/src/lv_widgets/lv_checkbox.h
+++ b/src/lv_widgets/lv_checkbox.h
@@ -26,7 +26,7 @@ extern "C" {
 #error "lv_cb: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
 #endif
 
-#include "../lv_core/lv_obj.h"
+#include "lv_label.h"
 
 /*********************
  *      DEFINES
@@ -38,12 +38,10 @@ extern "C" {
 
 /*Data of check box*/
 typedef struct {
-    /*No inherited ext, derived from the base object */
+    lv_label_ext_t label_ext;
 
     /*New data for this widget */
     lv_style_list_t style_bullet;
-    char * text;              /*Pointer to button*/
-    uint32_t static_txt :1;
 } lv_checkbox_ext_t;
 
 /** Checkbox styles. */
@@ -70,21 +68,28 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy);
  * Setter functions
  *====================*/
 
+
 /**
  * Set the text of a check box. `txt` will be copied and may be deallocated
  * after this function returns.
  * @param cb pointer to a check box
- * @param txt the text of the check box.
+ * @param txt the text of the check box. NULL to refresh with the current text.
  */
-void lv_checkbox_set_text(lv_obj_t * cb, const char * txt);
+static inline void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
+{
+    lv_label_set_text(cb, txt);
+}
 
 /**
  * Set the text of a check box. `txt` must not be deallocated during the life
  * of this checkbox.
  * @param cb pointer to a check box
- * @param txt the text of the check box.
+ * @param txt the text of the check box. NULL to refresh with the current text.
  */
-void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt);
+static inline void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
+{
+    lv_label_set_text_static(cb, txt);
+}
 
 /**
  * Set the state of the check box
@@ -117,7 +122,10 @@ static inline void lv_checkbox_set_disabled(lv_obj_t * cb, bool dis)
  * @param cb pointer to check box object
  * @return pointer to the text of the check box
  */
-const char * lv_checkbox_get_text(const lv_obj_t * cb);
+static inline const char * lv_checkbox_get_text(const lv_obj_t * cb)
+{
+    return lv_label_get_text(cb);
+}
 
 /**
  * Get the current state of the check box

From ab087967366052e23276f394726de2620b7ab007 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 16 Sep 2020 22:34:45 +0200
Subject: [PATCH 36/84] add grid fill

---
 src/lv_core/lv_grid.c | 113 ++++++++++++++++++++++++++++++------------
 src/lv_core/lv_grid.h |  27 ++++++++--
 src/lv_core/lv_obj.c  |  10 +++-
 3 files changed, 113 insertions(+), 37 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index b7aadcfce..d8e8d3c8a 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -120,8 +120,8 @@ void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
         calc_implicit_rows(cont, calc_out);
     }
     else if(!cont->grid->col_dsc && cont->grid->row_dsc) {
-        calc_implicit_cols(cont, calc_out);
         calc_explicit_rows(cont, calc_out);
+        calc_implicit_cols(cont, calc_out);
     }
 
     bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
@@ -183,6 +183,37 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
     return false;
 }
 
+/**
+ * Check if the object's grid columns are "fill" type
+ * @param obj pointer to an object
+ * @return true: fill type; false: not fill type
+ */
+bool _lv_grid_has_fill_col(struct _lv_obj_t * obj)
+{
+    if(obj->grid == NULL) return false;
+    if(obj->grid->col_dsc == NULL)  return false;
+    if(obj->grid->col_dsc_len != 1)  return false;
+    if(_GRID_IS_FILL(obj->grid->col_dsc[0]) == false) return false;
+
+    return true;
+}
+
+/**
+ * Check if the object's grid rows are "fill" type
+ * @param obj pointer to an object
+ * @return true: fill type; false: not fill type
+ */
+bool _lv_grid_has_fill_row(struct _lv_obj_t * obj)
+{
+    if(obj->grid == NULL) return false;
+    if(obj->grid->row_dsc == NULL)  return false;
+    if(obj->grid->row_dsc_len != 1)  return false;
+    if(_GRID_IS_FILL(obj->grid->row_dsc[0]) == false) return false;
+
+    return true;
+}
+
+
 /**
  * Refresh the all grid item on a container
  * @param cont pointer to a grid container object
@@ -246,33 +277,52 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
     const lv_grid_t * grid = cont->grid;
     uint32_t i;
 
-    calc->col_num = grid->col_dsc_len;
+    lv_coord_t cont_w = lv_obj_get_width_fit(cont);
+    bool filled = false;
+    if(grid->col_dsc_len == 1 && _GRID_IS_FILL(grid->col_dsc[0])) filled = true;
+
+    if(filled) {
+        lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
+        /* Get number of tracks fitting to the content
+         * Add the gap to cont_w because here is no gap after the last track so compensate it*/
+        calc->col_num = (cont_w + grid->col_gap) / (fill_w + grid->col_gap);
+    } else {
+        calc->col_num = grid->col_dsc_len;
+    }
     calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
     calc->w = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
-    uint32_t col_fr_cnt = 0;
-    lv_coord_t grid_w = 0;
-    bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
-
-    for(i = 0; i < grid->col_dsc_len; i++) {
-        lv_coord_t x = grid->col_dsc[i];
-        if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
-        else {
-            calc->w[i] = x;
-            grid_w += x;
+    /*If filled, it's simple: every track has fill size*/
+    if(filled) {
+        lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
+        for(i = 0; i < calc->col_num; i++) {
+            calc->w[i] = fill_w;
         }
-    }
+    } else {
+        uint32_t col_fr_cnt = 0;
+        lv_coord_t grid_w = 0;
+        bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
 
-    lv_coord_t cont_w = lv_obj_get_width_fit(cont) - grid->col_gap * (grid->col_dsc_len - 1);
-    lv_coord_t free_w = cont_w - grid_w;
-
-    for(i = 0; i < grid->col_dsc_len; i++) {
-        lv_coord_t x = grid->col_dsc[i];
-        if(_GRID_IS_FR(x)) {
-            if(auto_w) calc->w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
+        for(i = 0; i < calc->col_num; i++) {
+            lv_coord_t x = grid->col_dsc[i];
+            if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
             else {
-                lv_coord_t f = _GRID_GET_FR(x);
-                calc->w[i] = (free_w * f) / col_fr_cnt;
+                calc->w[i] = x;
+                grid_w += x;
+            }
+        }
+
+        cont_w -= grid->col_gap * (calc->col_num - 1);
+        lv_coord_t free_w = cont_w - grid_w;
+
+        for(i = 0; i < calc->col_num; i++) {
+            lv_coord_t x = grid->col_dsc[i];
+            if(_GRID_IS_FR(x)) {
+                if(auto_w) calc->w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
+                else {
+                    lv_coord_t f = _GRID_GET_FR(x);
+                    calc->w[i] = (free_w * f) / col_fr_cnt;
+                }
             }
         }
     }
@@ -355,7 +405,7 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     const lv_grid_t * grid = cont->grid;
     uint32_t child_cnt = lv_obj_count_children(cont);
-    calc->row_num  = ((child_cnt + grid->col_dsc_len - 1) / grid->col_dsc_len); /*+ grid->col_dsc_len - 1 to round up*/
+    calc->row_num  = ((child_cnt + calc->col_num - 1) / calc->col_num); /*+ grid->col_dsc_len - 1 to round up*/
     calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * (calc->row_num + 1));   /*+1 to allow some limit checks later*/
     calc->y = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
 
@@ -370,7 +420,7 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
             else h = lv_obj_get_height(child);
             calc->h[row_i] = LV_MATH_MAX(calc->h[row_i], h);
             col_i++;
-            if(col_i == grid->col_dsc_len) {
+            if(col_i == calc->col_num) {
                 col_i = 0;
                 row_i++;
                 calc->h[row_i] = 0;
@@ -413,12 +463,12 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
 
             if(cont->grid->row_dsc == NULL) {
                 hint->col++;
-                if(hint->col >= cont->grid->col_dsc_len) {
+                if(hint->col >= calc->col_num) {
                     hint->col = 0;
                     hint->row++;
                 }
             } else {
-                if(hint->row >= cont->grid->row_dsc_len) {
+                if(hint->row >= calc->row_num) {
                     hint->row = 0;
                     hint->col++;
                 }
@@ -438,11 +488,11 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
             }
 
             if(cont->grid->row_dsc == NULL) {
-                col_pos = child_id % cont->grid->col_dsc_len;
-                row_pos = child_id / cont->grid->col_dsc_len;
+                col_pos = child_id % calc->col_num;
+                row_pos = child_id / calc->col_num;
             } else {
-                col_pos = child_id / cont->grid->row_dsc_len;
-                row_pos = child_id % cont->grid->row_dsc_len;
+                col_pos = child_id / calc->row_num;
+                row_pos = child_id % calc->row_num;
             }
         }
     }
@@ -452,7 +502,7 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
     lv_coord_t col_w = col_x2 - col_x1;
 
     lv_coord_t row_y1 = calc->y[row_pos];
-    lv_coord_t row_y2 = calc->y[row_pos + row_span - 1] + calc->h[col_pos + col_span - 1];
+    lv_coord_t row_y2 = calc->y[row_pos + row_span - 1] + calc->h[row_pos + row_span - 1];
     lv_coord_t row_h = row_y2 - row_y1;
 
     uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
@@ -549,6 +599,7 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
         /*With spaced placements gap will be calculated from the remaining space*/
         if(place == LV_GRID_SPACE_AROUND || place == LV_GRID_SPACE_BETWEEN || place == LV_GRID_SPACE_EVENLY) {
             gap = 0;
+            if(track_num == 1) place = LV_GRID_CENTER;
         }
 
         /*Get the full grid size with gap*/
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 4f3dfc907..4c524ffe5 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -46,11 +46,15 @@ extern "C" {
 #define _GRID_CELL_SIZE_FR    1     /* The cell size is set in free units*/
 
 #define LV_GRID_FR(x)   (LV_COORD_MAX + (x))
+#define LV_GRID_FILL(x)   (LV_COORD_MAX + 256 + (x))
 
-#define _GRID_IS_PX(x) ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
-#define _GRID_IS_FR(x) (x > LV_COORD_MAX ? true : false)
-#define _GRID_IS_AUTO(x) (x == LV_GRID_AUTO ? true : false)
-#define _GRID_GET_FR(x) ((x) - LV_COORD_MAX)
+#define _GRID_FR_MAX        256
+#define _GRID_IS_PX(x)      ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
+#define _GRID_IS_FR(x)      ((x) > LV_COORD_MAX && (x) <  LV_COORD_MAX + _GRID_FR_MAX ? true : false)
+#define _GRID_IS_FILL(x)    ((x) > LV_COORD_MAX + _GRID_FR_MAX ? true : false)
+#define _GRID_IS_AUTO(x)    (x == LV_GRID_AUTO ? true : false)
+#define _GRID_GET_FR(x)     ((x) - LV_COORD_MAX)
+#define _GRID_GET_FILL(x)     ((x) - LV_COORD_MAX - _GRID_FR_MAX)
 
 
 /**
@@ -86,6 +90,7 @@ typedef struct {
     lv_coord_t row_gap;
     uint8_t col_place;
     uint8_t row_place;
+
 }lv_grid_t;
 
 typedef struct {
@@ -139,6 +144,20 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
 
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 
+
+/**
+ * Check if the object's grid columns are "fill" type
+ * @param obj pointer to an object
+ * @return true: fill type; false: not fill type
+ */
+bool _lv_grid_has_fill_col(struct _lv_obj_t * obj);
+/**
+ * Check if the object's grid rows are "fill" type
+ * @param obj pointer to an object
+ * @return true: fill type; false: not fill type
+ */
+bool _lv_grid_has_fill_row(struct _lv_obj_t * obj);
+
 void _lv_grid_full_refresh(lv_obj_t * cont);
 
 void lv_grid_item_refr_pos(lv_obj_t * item);
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 04bb0453c..929b825ef 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1883,8 +1883,14 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(param && ((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
-                     (lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj))))
+            bool col_fr =   _lv_grid_has_fr_col(obj);
+            bool col_fill = _lv_grid_has_fill_col(obj);
+            bool row_fr =   _lv_grid_has_fr_row(obj);
+            bool row_fill = _lv_grid_has_fill_row(obj);
+
+            if(param == NULL ||
+              (lv_area_get_width(param) != lv_obj_get_width(obj) && (col_fr || col_fill)) ||
+              (lv_area_get_height(param) != lv_obj_get_height(obj) && (row_fr || row_fill)))
         {
             _lv_grid_full_refresh(obj);
         }

From c53da44ff52276a69e6a3ea69dfee31d15555f36 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 16 Sep 2020 22:35:01 +0200
Subject: [PATCH 37/84] reenable lv_img

---
 src/lv_widgets/lv_img.c | 69 +++++++++++++++--------------------------
 src/lv_widgets/lv_img.h | 13 ++------
 2 files changed, 28 insertions(+), 54 deletions(-)

diff --git a/src/lv_widgets/lv_img.c b/src/lv_widgets/lv_img.c
index d7fb1a85d..3cea6f477 100644
--- a/src/lv_widgets/lv_img.c
+++ b/src/lv_widgets/lv_img.c
@@ -96,8 +96,9 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy)
 
     if(copy == NULL) {
         lv_theme_apply(img, LV_THEME_IMAGE);
-        lv_obj_set_click(img, false);
-        lv_obj_set_adv_hittest(img, true); /*Images have fast hit-testing*/
+        lv_obj_clear_flag(img, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_add_flag(img, LV_OBJ_FLAG_ADV_HITTEST);
+
         /* Enable auto size for non screens
          * because image screens are wallpapers
          * and must be screen sized*/
@@ -121,7 +122,7 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_img_set_src(img, copy_ext->src);
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(img, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(img, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("image created");
@@ -229,7 +230,7 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img)
     }
 
     /*Provide enough room for the rotated corners*/
-    if(ext->angle || ext->zoom != LV_IMG_ZOOM_NONE) lv_obj_refresh_ext_draw_pad(img);
+    if(ext->angle || ext->zoom != LV_IMG_ZOOM_NONE) _lv_obj_refresh_ext_draw_pad(img);
 
     lv_obj_invalidate(img);
 }
@@ -289,13 +290,13 @@ void lv_img_set_offset_y(lv_obj_t * img, lv_coord_t y)
  * Set the rotation center of the image.
  * The image will be rotated around this point
  * @param img pointer to an image object
- * @param pivot_x rotation center x of the image
- * @param pivot_y rotation center y of the image
+ * @param x rotation center x of the image
+ * @param y rotation center y of the image
  */
-void lv_img_set_pivot(lv_obj_t * img, lv_coord_t pivot_x, lv_coord_t pivot_y)
+void lv_img_set_pivot(lv_obj_t * img, lv_coord_t x, lv_coord_t y)
 {
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
-    if(ext->pivot.x == pivot_x && ext->pivot.y == pivot_y) return;
+    if(ext->pivot.x == x && ext->pivot.y == y) return;
 
     lv_style_int_t transf_zoom = lv_obj_get_style_transform_zoom(img, LV_IMG_PART_MAIN);
     transf_zoom = (transf_zoom * ext->zoom) >> 8;
@@ -313,9 +314,9 @@ void lv_img_set_pivot(lv_obj_t * img, lv_coord_t pivot_x, lv_coord_t pivot_y)
     a.y2 += img->coords.y1;
     lv_obj_invalidate_area(img, &a);
 
-    ext->pivot.x = pivot_x;
-    ext->pivot.y = pivot_y;
-    lv_obj_refresh_ext_draw_pad(img);
+    ext->pivot.x = x;
+    ext->pivot.y = y;
+    _lv_obj_refresh_ext_draw_pad(img);
 
     _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, transf_zoom, &ext->pivot);
     a.x1 += img->coords.x1;
@@ -354,7 +355,7 @@ void lv_img_set_angle(lv_obj_t * img, int16_t angle)
     lv_obj_invalidate_area(img, &a);
 
     ext->angle = angle;
-    lv_obj_refresh_ext_draw_pad(img);
+    _lv_obj_refresh_ext_draw_pad(img);
 
     _lv_img_buf_get_transformed_area(&a, w, h, transf_angle + ext->angle, transf_zoom, &ext->pivot);
     a.x1 += img->coords.x1;
@@ -397,7 +398,7 @@ void lv_img_set_zoom(lv_obj_t * img, uint16_t zoom)
     lv_obj_invalidate_area(img, &a);
 
     ext->zoom = zoom;
-    lv_obj_refresh_ext_draw_pad(img);
+    _lv_obj_refresh_ext_draw_pad(img);
 
     _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, (transf_zoom * ext->zoom) >> 8, &ext->pivot);
     a.x1 += img->coords.x1;
@@ -439,23 +440,6 @@ const void * lv_img_get_src(lv_obj_t * img)
     return ext->src;
 }
 
-/**
- * Get the name of the file set for an image
- * @param img pointer to an image
- * @return file name
- */
-const char * lv_img_get_file_name(const lv_obj_t * img)
-{
-    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
-
-    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
-
-    if(ext->src_type == LV_IMG_SRC_FILE)
-        return ext->src;
-    else
-        return "";
-}
-
 /**
  * Get the auto size enable attribute
  * @param img pointer to an image
@@ -621,7 +605,7 @@ static lv_design_res_t lv_img_design(lv_obj_t * img, const lv_area_t * clip_area
 
         /*If the border is drawn later disable loading its properties*/
         if(lv_obj_get_style_border_post(img, LV_OBJ_PART_MAIN)) {
-            bg_dsc.border_opa = LV_OPA_TRANSP;
+            bg_dsc.border_post = 1;
         }
 
 
@@ -779,22 +763,21 @@ static lv_design_res_t lv_img_design(lv_obj_t * img, const lv_area_t * clip_area
 static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
 {
     lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-
-        lv_get_style_info_t * info = param;
-        info->result = lv_img_get_style(img, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(img, sign, param);
-    }
 
     /* Include the ancient signal function */
     res = ancestor_signal(img, sign, param);
     if(res != LV_RES_OK) return res;
 
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
-    if(sign == LV_SIGNAL_CLEANUP) {
+
+    if(sign == LV_SIGNAL_GET_STYLE) {
+        lv_get_style_info_t * info = param;
+        info->result = lv_img_get_style(img, info->part);
+    }
+    else if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else  if(sign == LV_SIGNAL_CLEANUP) {
         if(ext->src_type == LV_IMG_SRC_FILE || ext->src_type == LV_IMG_SRC_SYMBOL) {
             lv_mem_free(ext->src);
             ext->src      = NULL;
@@ -838,8 +821,6 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
         img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, right);
         img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, top);
         img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, bottom);
-
-
     }
     else if(sign == LV_SIGNAL_HIT_TEST) {
         lv_hit_test_info_t * info = param;
@@ -866,7 +847,7 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
             info->result = _lv_area_is_point_on(&coords, info->point, 0);
         }
         else
-            info->result = lv_obj_is_point_on_coords(img, info->point);
+            info->result = _lv_obj_is_click_point_on(img, info->point);
     }
 
     return res;
diff --git a/src/lv_widgets/lv_img.h b/src/lv_widgets/lv_img.h
index 89b46bfaa..d73dbad61 100644
--- a/src/lv_widgets/lv_img.h
+++ b/src/lv_widgets/lv_img.h
@@ -103,10 +103,10 @@ void lv_img_set_offset_y(lv_obj_t * img, lv_coord_t y);
  * Set the rotation center of the image.
  * The image will be rotated around this point
  * @param img pointer to an image object
- * @param pivot_x rotation center x of the image
- * @param pivot_y rotation center y of the image
+ * @param x rotation center x of the image
+ * @param y rotation center y of the image
  */
-void lv_img_set_pivot(lv_obj_t * img, lv_coord_t pivot_x, lv_coord_t pivot_y);
+void lv_img_set_pivot(lv_obj_t * img, lv_coord_t x, lv_coord_t y);
 
 /**
  * Set the rotation angle of the image.
@@ -146,13 +146,6 @@ void lv_img_set_antialias(lv_obj_t * img, bool antialias);
  */
 const void * lv_img_get_src(lv_obj_t * img);
 
-/**
- * Get the name of the file set for an image
- * @param img pointer to an image
- * @return file name
- */
-const char * lv_img_get_file_name(const lv_obj_t * img);
-
 /**
  * Get the auto size enable attribute
  * @param img pointer to an image

From 33acf23949c80ef82a51d34699d4b0ce7471bfb4 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 17 Sep 2020 15:18:16 +0200
Subject: [PATCH 38/84] udpate lv_conf.h

---
 lv_conf_template.h     |  79 --------------
 src/lv_conf_internal.h | 229 -----------------------------------------
 2 files changed, 308 deletions(-)

diff --git a/lv_conf_template.h b/lv_conf_template.h
index 236daf929..9f295a079 100644
--- a/lv_conf_template.h
+++ b/lv_conf_template.h
@@ -564,12 +564,6 @@ typedef void * lv_obj_user_data_t;
 /*Button matrix (dependencies: -)*/
 #define LV_USE_BTNMATRIX     1
 
-/*Calendar (dependencies: -)*/
-#define LV_USE_CALENDAR 1
-#if LV_USE_CALENDAR
-#  define LV_CALENDAR_WEEK_STARTS_MONDAY    0
-#endif
-
 /*Canvas (dependencies: lv_img)*/
 #define LV_USE_CANVAS   1
 
@@ -582,12 +576,6 @@ typedef void * lv_obj_user_data_t;
 #  define LV_CHART_AXIS_TICK_LABEL_MAX_LEN    256
 #endif
 
-/*Container (dependencies: -*/
-#define LV_USE_CONT     1
-
-/*Color picker (dependencies: -*/
-#define LV_USE_CPICKER   1
-
 /*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/
 #define LV_USE_DROPDOWN    1
 #if LV_USE_DROPDOWN != 0
@@ -608,9 +596,6 @@ typedef void * lv_obj_user_data_t;
 #  define LV_IMGBTN_TILED 0
 #endif
 
-/*Keyboard (dependencies: lv_btnm)*/
-#define LV_USE_KEYBOARD       1
-
 /*Label (dependencies: -*/
 #define LV_USE_LABEL    1
 #if LV_USE_LABEL != 0
@@ -627,56 +612,12 @@ typedef void * lv_obj_user_data_t;
 #  define LV_LABEL_LONG_TXT_HINT          0
 #endif
 
-/*LED (dependencies: -)*/
-#define LV_USE_LED      1
-#if LV_USE_LED
-#  define LV_LED_BRIGHT_MIN  120      /*Minimal brightness*/
-#  define LV_LED_BRIGHT_MAX  255     /*Maximal brightness*/
-#endif
-
 /*Line (dependencies: -*/
 #define LV_USE_LINE     1
 
-/*List (dependencies: lv_page, lv_btn, lv_label, (lv_img optionally for icons ))*/
-#define LV_USE_LIST     1
-#if LV_USE_LIST != 0
-/*Default animation time of focusing to a list element [ms] (0: no animation)  */
-#  define LV_LIST_DEF_ANIM_TIME  100
-#endif
-
-/*Line meter (dependencies: *;)*/
-#define LV_USE_LINEMETER   1
-#if LV_USE_LINEMETER
-/* Draw line more precisely at cost of performance.
- * Useful if there are lot of lines any minor are visible
- * 0: No extra precision
- * 1: Some extra precision
- * 2: Best precision
- */
-#  define LV_LINEMETER_PRECISE    1
-#endif
-
 /*Mask (dependencies: -)*/
 #define LV_USE_OBJMASK  1
 
-/*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/
-#define LV_USE_MSGBOX     1
-
-/*Page (dependencies: lv_cont)*/
-#define LV_USE_PAGE     1
-#if LV_USE_PAGE != 0
-/*Focus default animation time [ms] (0: no animation)*/
-#  define LV_PAGE_DEF_ANIM_TIME     400
-#endif
-
-/*Preload (dependencies: lv_arc, lv_anim)*/
-#define LV_USE_SPINNER      1
-#if LV_USE_SPINNER != 0
-#  define LV_SPINNER_DEF_ARC_LENGTH   60      /*[deg]*/
-#  define LV_SPINNER_DEF_SPIN_TIME    1000    /*[ms]*/
-#  define LV_SPINNER_DEF_ANIM         LV_SPINNER_TYPE_SPINNING_ARC
-#endif
-
 /*Roller (dependencies: lv_ddlist)*/
 #define LV_USE_ROLLER    1
 #if LV_USE_ROLLER != 0
@@ -690,9 +631,6 @@ typedef void * lv_obj_user_data_t;
 /*Slider (dependencies: lv_bar)*/
 #define LV_USE_SLIDER    1
 
-/*Spinbox (dependencies: lv_ta)*/
-#define LV_USE_SPINBOX       1
-
 /*Switch (dependencies: lv_slider)*/
 #define LV_USE_SWITCH       1
 
@@ -709,23 +647,6 @@ typedef void * lv_obj_user_data_t;
 #  define LV_TABLE_COL_MAX    12
 #endif
 
-/*Tab (dependencies: lv_page, lv_btnm)*/
-#define LV_USE_TABVIEW      1
-#  if LV_USE_TABVIEW != 0
-/*Time of slide animation [ms] (0: no animation)*/
-#  define LV_TABVIEW_DEF_ANIM_TIME    300
-#endif
-
-/*Tileview (dependencies: lv_page) */
-#define LV_USE_TILEVIEW     1
-#if LV_USE_TILEVIEW
-/*Time of slide animation [ms] (0: no animation)*/
-#  define LV_TILEVIEW_DEF_ANIM_TIME   300
-#endif
-
-/*Window (dependencies: lv_cont, lv_btn, lv_label, lv_img, lv_page)*/
-#define LV_USE_WIN      1
-
 /*==================
  * Non-user section
  *==================*/
diff --git a/src/lv_conf_internal.h b/src/lv_conf_internal.h
index 5e6a9a15e..4c4d8e699 100644
--- a/src/lv_conf_internal.h
+++ b/src/lv_conf_internal.h
@@ -1409,24 +1409,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #  endif
 #endif
 
-/*Calendar (dependencies: -)*/
-#ifndef LV_USE_CALENDAR
-#  ifdef CONFIG_LV_USE_CALENDAR
-#    define LV_USE_CALENDAR CONFIG_LV_USE_CALENDAR
-#  else
-#    define  LV_USE_CALENDAR 1
-#  endif
-#endif
-#if LV_USE_CALENDAR
-#ifndef LV_CALENDAR_WEEK_STARTS_MONDAY
-#  ifdef CONFIG_LV_CALENDAR_WEEK_STARTS_MONDAY
-#    define LV_CALENDAR_WEEK_STARTS_MONDAY CONFIG_LV_CALENDAR_WEEK_STARTS_MONDAY
-#  else
-#    define  LV_CALENDAR_WEEK_STARTS_MONDAY    0
-#  endif
-#endif
-#endif
-
 /*Canvas (dependencies: lv_img)*/
 #ifndef LV_USE_CANVAS
 #  ifdef CONFIG_LV_USE_CANVAS
@@ -1463,24 +1445,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #endif
 #endif
 
-/*Container (dependencies: -*/
-#ifndef LV_USE_CONT
-#  ifdef CONFIG_LV_USE_CONT
-#    define LV_USE_CONT CONFIG_LV_USE_CONT
-#  else
-#    define  LV_USE_CONT     1
-#  endif
-#endif
-
-/*Color picker (dependencies: -*/
-#ifndef LV_USE_CPICKER
-#  ifdef CONFIG_LV_USE_CPICKER
-#    define LV_USE_CPICKER CONFIG_LV_USE_CPICKER
-#  else
-#    define  LV_USE_CPICKER   1
-#  endif
-#endif
-
 /*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/
 #ifndef LV_USE_DROPDOWN
 #  ifdef CONFIG_LV_USE_DROPDOWN
@@ -1537,15 +1501,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #endif
 #endif
 
-/*Keyboard (dependencies: lv_btnm)*/
-#ifndef LV_USE_KEYBOARD
-#  ifdef CONFIG_LV_USE_KEYBOARD
-#    define LV_USE_KEYBOARD CONFIG_LV_USE_KEYBOARD
-#  else
-#    define  LV_USE_KEYBOARD       1
-#  endif
-#endif
-
 /*Label (dependencies: -*/
 #ifndef LV_USE_LABEL
 #  ifdef CONFIG_LV_USE_LABEL
@@ -1592,31 +1547,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #endif
 #endif
 
-/*LED (dependencies: -)*/
-#ifndef LV_USE_LED
-#  ifdef CONFIG_LV_USE_LED
-#    define LV_USE_LED CONFIG_LV_USE_LED
-#  else
-#    define  LV_USE_LED      1
-#  endif
-#endif
-#if LV_USE_LED
-#ifndef LV_LED_BRIGHT_MIN
-#  ifdef CONFIG_LV_LED_BRIGHT_MIN
-#    define LV_LED_BRIGHT_MIN CONFIG_LV_LED_BRIGHT_MIN
-#  else
-#    define  LV_LED_BRIGHT_MIN  120      /*Minimal brightness*/
-#  endif
-#endif
-#ifndef LV_LED_BRIGHT_MAX
-#  ifdef CONFIG_LV_LED_BRIGHT_MAX
-#    define LV_LED_BRIGHT_MAX CONFIG_LV_LED_BRIGHT_MAX
-#  else
-#    define  LV_LED_BRIGHT_MAX  255     /*Maximal brightness*/
-#  endif
-#endif
-#endif
-
 /*Line (dependencies: -*/
 #ifndef LV_USE_LINE
 #  ifdef CONFIG_LV_USE_LINE
@@ -1626,49 +1556,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #  endif
 #endif
 
-/*List (dependencies: lv_page, lv_btn, lv_label, (lv_img optionally for icons ))*/
-#ifndef LV_USE_LIST
-#  ifdef CONFIG_LV_USE_LIST
-#    define LV_USE_LIST CONFIG_LV_USE_LIST
-#  else
-#    define  LV_USE_LIST     1
-#  endif
-#endif
-#if LV_USE_LIST != 0
-/*Default animation time of focusing to a list element [ms] (0: no animation)  */
-#ifndef LV_LIST_DEF_ANIM_TIME
-#  ifdef CONFIG_LV_LIST_DEF_ANIM_TIME
-#    define LV_LIST_DEF_ANIM_TIME CONFIG_LV_LIST_DEF_ANIM_TIME
-#  else
-#    define  LV_LIST_DEF_ANIM_TIME  100
-#  endif
-#endif
-#endif
-
-/*Line meter (dependencies: *;)*/
-#ifndef LV_USE_LINEMETER
-#  ifdef CONFIG_LV_USE_LINEMETER
-#    define LV_USE_LINEMETER CONFIG_LV_USE_LINEMETER
-#  else
-#    define  LV_USE_LINEMETER   1
-#  endif
-#endif
-#if LV_USE_LINEMETER
-/* Draw line more precisely at cost of performance.
- * Useful if there are lot of lines any minor are visible
- * 0: No extra precision
- * 1: Some extra precision
- * 2: Best precision
- */
-#ifndef LV_LINEMETER_PRECISE
-#  ifdef CONFIG_LV_LINEMETER_PRECISE
-#    define LV_LINEMETER_PRECISE CONFIG_LV_LINEMETER_PRECISE
-#  else
-#    define  LV_LINEMETER_PRECISE    1
-#  endif
-#endif
-#endif
-
 /*Mask (dependencies: -)*/
 #ifndef LV_USE_OBJMASK
 #  ifdef CONFIG_LV_USE_OBJMASK
@@ -1678,66 +1565,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #  endif
 #endif
 
-/*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/
-#ifndef LV_USE_MSGBOX
-#  ifdef CONFIG_LV_USE_MSGBOX
-#    define LV_USE_MSGBOX CONFIG_LV_USE_MSGBOX
-#  else
-#    define  LV_USE_MSGBOX     1
-#  endif
-#endif
-
-/*Page (dependencies: lv_cont)*/
-#ifndef LV_USE_PAGE
-#  ifdef CONFIG_LV_USE_PAGE
-#    define LV_USE_PAGE CONFIG_LV_USE_PAGE
-#  else
-#    define  LV_USE_PAGE     1
-#  endif
-#endif
-#if LV_USE_PAGE != 0
-/*Focus default animation time [ms] (0: no animation)*/
-#ifndef LV_PAGE_DEF_ANIM_TIME
-#  ifdef CONFIG_LV_PAGE_DEF_ANIM_TIME
-#    define LV_PAGE_DEF_ANIM_TIME CONFIG_LV_PAGE_DEF_ANIM_TIME
-#  else
-#    define  LV_PAGE_DEF_ANIM_TIME     400
-#  endif
-#endif
-#endif
-
-/*Preload (dependencies: lv_arc, lv_anim)*/
-#ifndef LV_USE_SPINNER
-#  ifdef CONFIG_LV_USE_SPINNER
-#    define LV_USE_SPINNER CONFIG_LV_USE_SPINNER
-#  else
-#    define  LV_USE_SPINNER      1
-#  endif
-#endif
-#if LV_USE_SPINNER != 0
-#ifndef LV_SPINNER_DEF_ARC_LENGTH
-#  ifdef CONFIG_LV_SPINNER_DEF_ARC_LENGTH
-#    define LV_SPINNER_DEF_ARC_LENGTH CONFIG_LV_SPINNER_DEF_ARC_LENGTH
-#  else
-#    define  LV_SPINNER_DEF_ARC_LENGTH   60      /*[deg]*/
-#  endif
-#endif
-#ifndef LV_SPINNER_DEF_SPIN_TIME
-#  ifdef CONFIG_LV_SPINNER_DEF_SPIN_TIME
-#    define LV_SPINNER_DEF_SPIN_TIME CONFIG_LV_SPINNER_DEF_SPIN_TIME
-#  else
-#    define  LV_SPINNER_DEF_SPIN_TIME    1000    /*[ms]*/
-#  endif
-#endif
-#ifndef LV_SPINNER_DEF_ANIM
-#  ifdef CONFIG_LV_SPINNER_DEF_ANIM
-#    define LV_SPINNER_DEF_ANIM CONFIG_LV_SPINNER_DEF_ANIM
-#  else
-#    define  LV_SPINNER_DEF_ANIM         LV_SPINNER_TYPE_SPINNING_ARC
-#  endif
-#endif
-#endif
-
 /*Roller (dependencies: lv_ddlist)*/
 #ifndef LV_USE_ROLLER
 #  ifdef CONFIG_LV_USE_ROLLER
@@ -1775,15 +1602,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #  endif
 #endif
 
-/*Spinbox (dependencies: lv_ta)*/
-#ifndef LV_USE_SPINBOX
-#  ifdef CONFIG_LV_USE_SPINBOX
-#    define LV_USE_SPINBOX CONFIG_LV_USE_SPINBOX
-#  else
-#    define  LV_USE_SPINBOX       1
-#  endif
-#endif
-
 /*Switch (dependencies: lv_slider)*/
 #ifndef LV_USE_SWITCH
 #  ifdef CONFIG_LV_USE_SWITCH
@@ -1836,53 +1654,6 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 #endif
 #endif
 
-/*Tab (dependencies: lv_page, lv_btnm)*/
-#ifndef LV_USE_TABVIEW
-#  ifdef CONFIG_LV_USE_TABVIEW
-#    define LV_USE_TABVIEW CONFIG_LV_USE_TABVIEW
-#  else
-#    define  LV_USE_TABVIEW      1
-#  endif
-#endif
-#  if LV_USE_TABVIEW != 0
-/*Time of slide animation [ms] (0: no animation)*/
-#ifndef LV_TABVIEW_DEF_ANIM_TIME
-#  ifdef CONFIG_LV_TABVIEW_DEF_ANIM_TIME
-#    define LV_TABVIEW_DEF_ANIM_TIME CONFIG_LV_TABVIEW_DEF_ANIM_TIME
-#  else
-#    define  LV_TABVIEW_DEF_ANIM_TIME    300
-#  endif
-#endif
-#endif
-
-/*Tileview (dependencies: lv_page) */
-#ifndef LV_USE_TILEVIEW
-#  ifdef CONFIG_LV_USE_TILEVIEW
-#    define LV_USE_TILEVIEW CONFIG_LV_USE_TILEVIEW
-#  else
-#    define  LV_USE_TILEVIEW     1
-#  endif
-#endif
-#if LV_USE_TILEVIEW
-/*Time of slide animation [ms] (0: no animation)*/
-#ifndef LV_TILEVIEW_DEF_ANIM_TIME
-#  ifdef CONFIG_LV_TILEVIEW_DEF_ANIM_TIME
-#    define LV_TILEVIEW_DEF_ANIM_TIME CONFIG_LV_TILEVIEW_DEF_ANIM_TIME
-#  else
-#    define  LV_TILEVIEW_DEF_ANIM_TIME   300
-#  endif
-#endif
-#endif
-
-/*Window (dependencies: lv_cont, lv_btn, lv_label, lv_img, lv_page)*/
-#ifndef LV_USE_WIN
-#  ifdef CONFIG_LV_USE_WIN
-#    define LV_USE_WIN CONFIG_LV_USE_WIN
-#  else
-#    define  LV_USE_WIN      1
-#  endif
-#endif
-
 /*==================
  * Non-user section
  *==================*/

From f01bfcb6f6f11f0f4f07a4df2936b0b24fe788f0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 23 Sep 2020 12:25:01 +0200
Subject: [PATCH 39/84] imporve ddlist

---
 src/lv_core/lv_indev_scroll.c     |   7 +-
 src/lv_themes/lv_theme.c          |   1 -
 src/lv_themes/lv_theme_material.c |  20 --
 src/lv_themes/lv_theme_mono.c     |  24 --
 src/lv_themes/lv_theme_template.c |   3 -
 src/lv_widgets/lv_dropdown.c      | 372 ++++++++++--------------------
 src/lv_widgets/lv_dropdown.h      |  47 +---
 7 files changed, 142 insertions(+), 332 deletions(-)

diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 6a3e808fb..817bc4155 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -120,7 +120,6 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
                 dirs_candidate = LV_SCROLL_DIR_HOR;
             }
 
-            /**/
             if(st <= 0) up_en = false;
             if(sb <= 0) down_en = false;
             if(sl <= 0) left_en = false;
@@ -202,6 +201,12 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
                 break;
             }
         }
+
+        lv_signal_send(obj, LV_SIGNAL_SCROLL_BEGIN, indev_act);
+        if(proc->reset_query) return;
+        lv_event_send(obj, LV_EVENT_SCROLL_BEGIN, indev_act);
+        if(proc->reset_query) return;
+
     }
 
     /*If there is no scroll object there is nothing to do*/
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index ace6b8777..70bac97dc 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -388,7 +388,6 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
         case LV_THEME_DROPDOWN:
             _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_LIST);
-            _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_obj_reset_style_list_no_refr(obj, LV_DROPDOWN_PART_SELECTED);
             break;
 #endif
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 3fbce82bf..0bda77ec6 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -1241,9 +1241,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->ddlist_page);
 
-            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->sb);
-
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->ddlist_sel);
             break;
@@ -1266,22 +1263,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-<<<<<<< HEAD
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
-            _lv_style_list_add_style(list, &styles->bg);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
-            _lv_style_list_add_style(list, &styles->table_cell);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
-            _lv_style_list_add_style(list, &styles->table_cell);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
-            _lv_style_list_add_style(list, &styles->table_cell);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
-            _lv_style_list_add_style(list, &styles->table_cell);
-=======
         {
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
@@ -1294,7 +1275,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
               list = lv_obj_get_style_list(obj, idx);
              _lv_style_list_add_style(list, &styles->table_cell);
             }
->>>>>>> dev
             break;
         }
 #endif
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index 15e643eea..bc12cad59 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -842,9 +842,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->big_line_space);
 
-            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->sb);
-
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
@@ -867,26 +864,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-<<<<<<< HEAD
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
-            _lv_style_list_add_style(list, &styles->bg);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
-            _lv_style_list_add_style(list, &styles->bg);
-            _lv_style_list_add_style(list, &styles->no_radius);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
-            _lv_style_list_add_style(list, &styles->bg);
-            _lv_style_list_add_style(list, &styles->no_radius);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
-            _lv_style_list_add_style(list, &styles->bg);
-            _lv_style_list_add_style(list, &styles->no_radius);
-
-            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
-            _lv_style_list_add_style(list, &styles->bg);
-            _lv_style_list_add_style(list, &styles->no_radius);
-=======
         {
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
@@ -900,7 +877,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
               _lv_style_list_add_style(list, &styles->bg);
               _lv_style_list_add_style(list, &styles->no_radius);
             }
->>>>>>> dev
             break;
          }
 #endif
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index fd00ac7e9..39a15dcf8 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -696,9 +696,6 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
 
-            list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->bg);
-
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
diff --git a/src/lv_widgets/lv_dropdown.c b/src/lv_widgets/lv_dropdown.c
index 4555c719e..ea3751f1c 100644
--- a/src/lv_widgets/lv_dropdown.c
+++ b/src/lv_widgets/lv_dropdown.c
@@ -36,22 +36,21 @@
  *      TYPEDEFS
  **********************/
 typedef struct {
-    lv_page_ext_t page;
+    /*No inherited ext*/
     lv_obj_t * ddlist;      /*Pointer to the ddlist where the page belongs*/
-} lv_dropdown_page_ext_t;
+} lv_dropdown_list_ext_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
 static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_design_res_t lv_dropdown_page_design(lv_obj_t * ddlist, const lv_area_t * clip_area, lv_design_mode_t mode);
+static lv_design_res_t lv_dropdown_list_design(lv_obj_t * ddlist, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * param);
-static lv_res_t lv_dropdown_page_signal(lv_obj_t * page, lv_signal_t sign, void * param);
-static lv_res_t lv_dropdown_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
+static lv_res_t lv_dropdown_page_signal(lv_obj_t * list, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_dropdown_get_style(lv_obj_t * ddlist, uint8_t part);
 static void draw_box(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id, lv_state_t state);
 static void draw_box_label(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id, lv_state_t state);
-static lv_res_t page_release_handler(lv_obj_t * page);
+static lv_res_t list_release_handler(lv_obj_t * page);
 static void page_press_handler(lv_obj_t * page);
 static uint16_t get_id_on_point(lv_obj_t * ddlist, lv_coord_t x, lv_coord_t y);
 static void position_to_selected(lv_obj_t * ddlist);
@@ -61,10 +60,9 @@ static lv_obj_t * get_label(const lv_obj_t * ddlist);
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
-static lv_signal_cb_t ancestor_page_signal;
-static lv_signal_cb_t ancestor_page_scrl_signal;
+static lv_signal_cb_t ancestor_list_signal;
 static lv_design_cb_t ancestor_design;
-static lv_design_cb_t ancestor_page_design;
+static lv_design_cb_t ancestor_list_design;
 
 /**********************
  *      MACROS
@@ -102,20 +100,18 @@ lv_obj_t * lv_dropdown_create(lv_obj_t * par, const lv_obj_t * copy)
     }
 
     /*Initialize the allocated 'ext' */
-    ext->page          = NULL;
+    ext->list          = NULL;
     ext->options     = NULL;
     ext->symbol         = LV_SYMBOL_DOWN;
-    ext->text         = "Select";
+    ext->text         = NULL;
     ext->static_txt = 1;
-    ext->show_selected   = 1;
     ext->sel_opt_id      = 0;
     ext->sel_opt_id_orig = 0;
     ext->pr_opt_id = LV_DROPDOWN_PR_NONE;
     ext->option_cnt      = 0;
-    ext->dir = LV_DROPDOWN_DIR_DOWN;
+    ext->dir = LV_DIR_BOTTOM;
     ext->max_height = (3 * lv_disp_get_ver_res(NULL)) / 4;
-    lv_style_list_init(&ext->style_page);
-    lv_style_list_init(&ext->style_scrlbar);
+    lv_style_list_init(&ext->style_list);
     lv_style_list_init(&ext->style_selected);
 
     /*The signal and design functions are not copied so set them here*/
@@ -142,10 +138,8 @@ lv_obj_t * lv_dropdown_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->max_height      = copy_ext->max_height;
         ext->text      = copy_ext->text;
         ext->dir      = copy_ext->dir;
-        ext->show_selected      = copy_ext->show_selected;
-        lv_style_list_copy(&ext->style_page, &copy_ext->style_page);
+        lv_style_list_copy(&ext->style_list, &copy_ext->style_list);
         lv_style_list_copy(&ext->style_selected, &copy_ext->style_selected);
-        lv_style_list_copy(&ext->style_scrlbar, &copy_ext->style_scrlbar);
     }
 
     LV_LOG_INFO("drop down list created");
@@ -174,7 +168,7 @@ void lv_dropdown_set_text(lv_obj_t * ddlist, const char * txt)
 }
 
 /**
- * Clear any options in a drop down list.  Static or dynamic.
+ * Clear all options in a drop down list.  Static or dynamic.
  * @param ddlist pointer to drop down list object
  */
 void lv_dropdown_clear_options(lv_obj_t * ddlist)
@@ -347,7 +341,7 @@ void lv_dropdown_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
     ext->sel_opt_id      = sel_opt < ext->option_cnt ? sel_opt : ext->option_cnt - 1;
     ext->sel_opt_id_orig = ext->sel_opt_id;
     /*Move the list to show the current option*/
-    if(ext->page != NULL) {
+    if(ext->list != NULL) {
         lv_obj_invalidate(ddlist);
     }
 }
@@ -355,9 +349,9 @@ void lv_dropdown_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
 /**
  * Set the direction of the a drop down list
  * @param ddlist pointer to a drop down list object
- * @param dir LV_DROPDOWN_DIR_LEF/RIGHT/TOP/BOTTOM
+ * @param dir LV_DIR_LEFT/RIGHT/TOP/BOTTOM
  */
-void lv_dropdown_set_dir(lv_obj_t * ddlist, lv_dropdown_dir_t dir)
+void lv_dropdown_set_dir(lv_obj_t * ddlist, lv_dir_t dir)
 {
     LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
 
@@ -382,16 +376,6 @@ void lv_dropdown_set_max_height(lv_obj_t * ddlist, lv_coord_t h)
     if(ext->max_height == h) return;
 
     ext->max_height = h;
-
-    if(ext->page) {
-        if(h == 0) {
-            lv_cont_set_fit(ext->page, LV_FIT_TIGHT);
-        }
-        else {
-            lv_cont_set_fit2(ext->page, LV_FIT_TIGHT, LV_FIT_NONE);
-            lv_obj_set_height(ext->page, h);
-        }
-    }
 }
 
 /**
@@ -408,23 +392,6 @@ void lv_dropdown_set_symbol(lv_obj_t * ddlist, const char * symbol)
     lv_obj_invalidate(ddlist);
 }
 
-/**
- * Set whether the ddlist highlight the last selected option and display its text or not
- * @param ddlist pointer to a drop down list object
- * @param show true/false
- */
-void lv_dropdown_set_show_selected(lv_obj_t * ddlist, bool show)
-{
-    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
-
-    lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    if(ext->show_selected == show) return;
-
-    ext->show_selected = show;
-
-    lv_obj_invalidate(ddlist);
-}
-
 /*=====================
  * Getter functions
  *====================*/
@@ -545,9 +512,9 @@ const char * lv_dropdown_get_symbol(lv_obj_t * ddlist)
 /**
  * Get the direction of the drop down list
  * @param ddlist pointer to a drop down list object
- * @return LV_DROPDOWN_DIR_LEF/RIGHT/TOP/BOTTOM
+ * @return LV_DIR_LEF/RIGHT/TOP/BOTTOM
  */
-lv_dropdown_dir_t lv_dropdown_get_dir(const lv_obj_t * ddlist)
+lv_dir_t lv_dropdown_get_dir(const lv_obj_t * ddlist)
 {
     LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
 
@@ -556,21 +523,6 @@ lv_dropdown_dir_t lv_dropdown_get_dir(const lv_obj_t * ddlist)
     return ext->dir;
 }
 
-/**
- * Get whether the ddlist highlight the last selected option and display its text or not
- * @param ddlist pointer to a drop down list object
- * @return true/false
- */
-bool lv_dropdown_get_show_selected(lv_obj_t * ddlist)
-{
-    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
-
-    lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-
-    return ext->show_selected ? true : false;
-
-}
-
 /*=====================
  * Other functions
  *====================*/
@@ -582,44 +534,38 @@ bool lv_dropdown_get_show_selected(lv_obj_t * ddlist)
 void lv_dropdown_open(lv_obj_t * ddlist)
 {
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    if(ext->page) return;
+    if(ext->list) return;
 
-    ext->page = lv_page_create(lv_obj_get_screen(ddlist), NULL);
-    lv_obj_add_protect(ext->page, LV_PROTECT_POS | LV_PROTECT_CLICK_FOCUS);
-    lv_obj_add_protect(lv_page_get_scrollable(ext->page), LV_PROTECT_CLICK_FOCUS);
+    ext->list = lv_obj_create(lv_obj_get_screen(ddlist), NULL);
+    lv_obj_clear_flag(ext->list, LV_OBJ_FLAG_CLICK_FOCUSABLE);
 
-    if(ancestor_page_signal == NULL) ancestor_page_signal = lv_obj_get_signal_cb(ext->page);
-    if(ancestor_page_scrl_signal == NULL) ancestor_page_scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(
-                                                                                                   ext->page));
-    if(ancestor_page_design == NULL) ancestor_page_design = lv_obj_get_design_cb(ext->page);
+    if(ancestor_list_signal == NULL) ancestor_list_signal = lv_obj_get_signal_cb(ext->list);
+    if(ancestor_list_design == NULL) ancestor_list_design = lv_obj_get_design_cb(ext->list);
 
-    lv_dropdown_page_ext_t * page_ext = lv_obj_allocate_ext_attr(ext->page, sizeof(lv_dropdown_page_ext_t));
-    LV_ASSERT_MEM(page_ext);
-    if(page_ext == NULL) {
-        lv_obj_del(ext->page);
-        ext->page = NULL;
+    lv_dropdown_list_ext_t * list_ext = lv_obj_allocate_ext_attr(ext->list, sizeof(lv_dropdown_list_ext_t));
+    LV_ASSERT_MEM(list_ext);
+    if(list_ext == NULL) {
+        lv_obj_del(ext->list);
+        ext->list = NULL;
         return;
     }
-    page_ext->ddlist = ddlist;
+    list_ext->ddlist = ddlist;
 
-    lv_obj_set_design_cb(ext->page, lv_dropdown_page_design);
-    lv_obj_set_signal_cb(ext->page, lv_dropdown_page_signal);
-    lv_obj_set_signal_cb(lv_page_get_scrollable(ext->page), lv_dropdown_page_scrl_signal);
+    lv_obj_set_design_cb(ext->list, lv_dropdown_list_design);
+    lv_obj_set_signal_cb(ext->list, lv_dropdown_page_signal);
 
-    lv_style_list_copy(lv_obj_get_style_list(ext->page, LV_PAGE_PART_BG), &ext->style_page);
-    lv_style_list_copy(lv_obj_get_style_list(ext->page, LV_PAGE_PART_SCROLLBAR), &ext->style_scrlbar);
-    lv_obj_clean_style_list(ext->page, LV_PAGE_PART_SCROLLABLE);
-    lv_obj_refresh_style(ext->page, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+    lv_style_list_copy(_lv_obj_get_style_list(ext->list, LV_OBJ_PART_MAIN), &ext->style_list);
+    _lv_obj_refresh_style(ext->list, LV_OBJ_PART_MAIN, LV_STYLE_PROP_ALL);
 
-    lv_obj_t * label = lv_label_create(ext->page, NULL);
+    lv_obj_t * label = lv_label_create(ext->list, NULL);
     lv_label_set_text_static(label, ext->options);
 
-    lv_cont_set_fit2(ext->page, LV_FIT_TIGHT, LV_FIT_NONE);
-    /*Set small width to the width of the button*/
-    if(lv_obj_get_width(ext->page) < lv_obj_get_width(ddlist) &&
-       (ext->dir == LV_DROPDOWN_DIR_UP || ext->dir == LV_DROPDOWN_DIR_DOWN)) {
-        lv_cont_set_fit2(ext->page, LV_FIT_NONE, LV_FIT_NONE);
-        lv_obj_set_width(ext->page, lv_obj_get_width(ddlist));
+    /*Set smaller width to the width of the button*/
+    if(lv_obj_get_width(ext->list) < lv_obj_get_width(ddlist) &&
+       (ext->dir == LV_DIR_TOP || ext->dir == LV_DIR_BOTTOM)) {
+        lv_obj_set_width(ext->list, lv_obj_get_width(ddlist));
+    } else {
+        lv_obj_set_width(ext->list, LV_SIZE_AUTO);
     }
 
     lv_coord_t label_h = lv_obj_get_height(label);
@@ -630,13 +576,13 @@ void lv_dropdown_open(lv_obj_t * ddlist)
     lv_coord_t list_h = list_fit_h;
     if(list_h > ext->max_height) list_h = ext->max_height;
 
-    lv_dropdown_dir_t dir = ext->dir;
-    /*No place on the bottom? See if top is better.*/
-    if(ext->dir == LV_DROPDOWN_DIR_DOWN) {
+    lv_dir_t dir = ext->dir;
+    /*No space on the bottom? See if top is better.*/
+    if(ext->dir == LV_DIR_BOTTOM) {
         if(ddlist->coords.y2 + list_h > LV_VER_RES) {
             if(ddlist->coords.y1 > LV_VER_RES - ddlist->coords.y2) {
                 /*There is more space on the top, so make it drop up*/
-                dir = LV_DROPDOWN_DIR_UP;
+                dir = LV_DIR_TOP;
                 list_h = ddlist->coords.y1;
             }
             else {
@@ -644,12 +590,12 @@ void lv_dropdown_open(lv_obj_t * ddlist)
             }
         }
     }
-    /*No place on the top? See if bottom is better.*/
-    else if(ext->dir == LV_DROPDOWN_DIR_UP) {
+    /*No space on the top? See if bottom is better.*/
+    else if(ext->dir == LV_DIR_TOP) {
         if(ddlist->coords.y1 - list_h < 0) {
             if(ddlist->coords.y1 < LV_VER_RES - ddlist->coords.y2) {
                 /*There is more space on the top, so make it drop up*/
-                dir = LV_DROPDOWN_DIR_DOWN;
+                dir = LV_DIR_BOTTOM;
                 list_h = LV_VER_RES - ddlist->coords.y2;
             }
             else {
@@ -661,18 +607,18 @@ void lv_dropdown_open(lv_obj_t * ddlist)
     if(list_h > list_fit_h) list_h = list_fit_h;
     if(list_h > ext->max_height) list_h = ext->max_height;
 
-    lv_obj_set_height(ext->page, list_h);
+    lv_obj_set_height(ext->list, list_h);
 
     position_to_selected(ddlist);
 
-    if(dir == LV_DROPDOWN_DIR_DOWN)      lv_obj_align(ext->page, ddlist, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
-    else if(dir == LV_DROPDOWN_DIR_UP)   lv_obj_align(ext->page, ddlist, LV_ALIGN_OUT_TOP_LEFT, 0, 0);
-    else if(dir == LV_DROPDOWN_DIR_LEFT) lv_obj_align(ext->page, ddlist, LV_ALIGN_OUT_LEFT_TOP, 0, 0);
-    else if(dir == LV_DROPDOWN_DIR_RIGHT)lv_obj_align(ext->page, ddlist, LV_ALIGN_OUT_RIGHT_TOP, 0, 0);
+    if(dir == LV_DIR_BOTTOM)      lv_obj_align(ext->list, ddlist, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
+    else if(dir == LV_DIR_TOP)   lv_obj_align(ext->list, ddlist, LV_ALIGN_OUT_TOP_LEFT, 0, 0);
+    else if(dir == LV_DIR_LEFT) lv_obj_align(ext->list, ddlist, LV_ALIGN_OUT_LEFT_TOP, 0, 0);
+    else if(dir == LV_DIR_RIGHT)lv_obj_align(ext->list, ddlist, LV_ALIGN_OUT_RIGHT_TOP, 0, 0);
 
-    if(ext->dir == LV_DROPDOWN_DIR_LEFT || ext->dir == LV_DROPDOWN_DIR_RIGHT) {
-        if(ext->page->coords.y2 > LV_VER_RES) {
-            lv_obj_set_y(ext->page, lv_obj_get_y(ext->page) - (ext->page->coords.y2 - LV_VER_RES));
+    if(ext->dir == LV_DIR_LEFT || ext->dir == LV_DIR_RIGHT) {
+        if(ext->list->coords.y2 > LV_VER_RES) {
+            lv_obj_set_y(ext->list, lv_obj_get_y(ext->list) - (ext->list->coords.y2 - LV_VER_RES));
         }
     }
 }
@@ -684,11 +630,11 @@ void lv_dropdown_open(lv_obj_t * ddlist)
 void lv_dropdown_close(lv_obj_t * ddlist)
 {
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    if(ext->page == NULL) return;
+    if(ext->list == NULL) return;
 
     ext->pr_opt_id = LV_DROPDOWN_PR_NONE;
-    lv_obj_del(ext->page);
-    ext->page = NULL;
+    lv_obj_del(ext->list);
+    ext->list = NULL;
 }
 
 /**********************
@@ -728,8 +674,10 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
         lv_area_t txt_area;
         lv_point_t txt_size;
 
-        const char * opt_txt = ext->text;
-        if(ext->show_selected) {
+        /*If no text specified use the selected option*/
+        const char * opt_txt;
+        if(ext->text) opt_txt = ext->text;
+        else {
             char * buf = _lv_mem_buf_get(128);
             lv_dropdown_get_selected_str(ddlist, buf, 128);
             opt_txt = buf;
@@ -737,7 +685,7 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
 
         const char * txt;
 
-        txt = ext->dir != LV_DROPDOWN_DIR_LEFT ? opt_txt : ext->symbol;
+        txt = ext->dir != LV_DIR_LEFT ? opt_txt : ext->symbol;
         if(txt) {
             _lv_txt_get_size(&txt_size, txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
                              label_dsc.flag);
@@ -757,7 +705,7 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
             lv_draw_label(&txt_area, clip_area, &label_dsc, txt, NULL);
         }
 
-        txt = ext->dir != LV_DROPDOWN_DIR_LEFT ? ext->symbol : opt_txt;
+        txt = ext->dir != LV_DIR_LEFT ? ext->symbol : opt_txt;
         if(txt) {
             _lv_txt_get_size(&txt_size, txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
                              label_dsc.flag);
@@ -777,7 +725,7 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
             lv_draw_label(&txt_area, clip_area, &label_dsc, txt, NULL);
         }
 
-        if(ext->show_selected) {
+        if(ext->text == NULL) {
             _lv_mem_buf_release((char *)opt_txt);
         }
 
@@ -790,8 +738,8 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
 }
 
 /**
- * Handle the drawing related tasks of the drop down list's page
- * @param page pointer to an object
+ * Handle the drawing related tasks of the drop down list's list
+ * @param list pointer to an object
  * @param clip_area the object will be drawn only in this area
  * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
  *                                  (return 'true' if yes)
@@ -799,27 +747,27 @@ static lv_design_res_t lv_dropdown_design(lv_obj_t * ddlist, const lv_area_t * c
  *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
  * @param return an element of `lv_design_res_t`
  */
-static lv_design_res_t lv_dropdown_page_design(lv_obj_t * page, const lv_area_t * clip_area, lv_design_mode_t mode)
+static lv_design_res_t lv_dropdown_list_design(lv_obj_t * page, const lv_area_t * clip_area, lv_design_mode_t mode)
 {
     /*Return false if the object is not covers the mask_p area*/
     if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_page_design(page, clip_area, mode);
+        return ancestor_list_design(page, clip_area, mode);
     }
     /*Draw the object*/
     else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_page_design(page, clip_area, mode);
+        ancestor_list_design(page, clip_area, mode);
 
-        lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
+        lv_dropdown_list_ext_t * page_ext = lv_obj_get_ext_attr(page);
         lv_obj_t * ddlist = page_ext->ddlist;
         lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
         /*Draw the boxes if the page is not being deleted*/
-        if(ext->page) {
+        if(ext->list) {
             /* Clip area might be too large too to shadow but
              * the selected option can be drawn on only the background*/
             lv_area_t clip_area_core;
             bool has_common;
-            has_common = _lv_area_intersect(&clip_area_core, clip_area, &ext->page->coords);
+            has_common = _lv_area_intersect(&clip_area_core, clip_area, &ext->list->coords);
             if(has_common) {
                 if(ext->pr_opt_id != LV_DROPDOWN_PR_NONE) {
                     draw_box(ddlist, &clip_area_core, ext->pr_opt_id, LV_STATE_PRESSED);
@@ -831,21 +779,21 @@ static lv_design_res_t lv_dropdown_page_design(lv_obj_t * page, const lv_area_t
     }
     /*Post draw when the children are drawn*/
     else if(mode == LV_DESIGN_DRAW_POST) {
-        /*Draw the scrollbar in the ancestor page design function*/
-        ancestor_page_design(page, clip_area, mode);
+        /*Draw the scrollbar in the ancestor list design function*/
+        ancestor_list_design(page, clip_area, mode);
 
         /*Redraw the text on the selected area with a different color*/
-        lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
+        lv_dropdown_list_ext_t * page_ext = lv_obj_get_ext_attr(page);
         lv_obj_t * ddlist = page_ext->ddlist;
         lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
-        /*Draw the box labels if the page is not being deleted*/
-        if(ext->page) {
+        /*Draw the box labels if the list is not being deleted*/
+        if(ext->list) {
             /* Clip area might be too large too to shadow but
              * the selected option can be drawn on only the background*/
             lv_area_t clip_area_core;
             bool has_common;
-            has_common = _lv_area_intersect(&clip_area_core, clip_area, &ext->page->coords);
+            has_common = _lv_area_intersect(&clip_area_core, clip_area, &ext->list->coords);
             if(has_common) {
                 if(ext->pr_opt_id != LV_DROPDOWN_PR_NONE) {
                     draw_box_label(ddlist, &clip_area_core, ext->pr_opt_id, LV_STATE_PRESSED);
@@ -873,7 +821,7 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
     /* Include the ancient signal function */
     res = ancestor_signal(ddlist, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
@@ -883,14 +831,6 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
         if(info->result != NULL) return LV_RES_OK;
         return LV_RES_OK;
     }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        lv_get_state_info_t * info = param;
-        if(info->part == LV_DROPDOWN_PART_LIST ||
-           info->part == LV_DROPDOWN_PART_SCROLLBAR ||
-           info->part == LV_DROPDOWN_PART_SELECTED) {
-            info->result = lv_obj_get_state(ext->page, LV_PAGE_PART_BG);
-        }
-    }
     else if(sign == LV_SIGNAL_CLEANUP) {
         lv_dropdown_close(ddlist);
         if(ext->static_txt == 0) {
@@ -898,10 +838,9 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
             ext->options = NULL;
         }
 
-        /*`lv_obj_clean_style_list` is not required because these styles are only copied to the page
+        /*`lv_obj_clean_style_list` is not required because these styles are only copied to the list
          * so they can have transitions or other object related things. */
-        _lv_style_list_reset(&ext->style_page);
-        _lv_style_list_reset(&ext->style_scrlbar);
+        _lv_style_list_reset(&ext->style_list);
         _lv_style_list_reset(&ext->style_selected);
 
     }
@@ -926,8 +865,8 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
     }
     else if(sign == LV_SIGNAL_RELEASED) {
         lv_indev_t * indev = lv_indev_get_act();
-        if(lv_indev_is_scrolling(indev) == false) {
-            if(ext->page) {
+        if(lv_indev_get_scroll_obj(indev) == NULL) {
+            if(ext->list) {
                 lv_dropdown_close(ddlist);
                 if(ext->sel_opt_id_orig != ext->sel_opt_id) {
                     ext->sel_opt_id_orig = ext->sel_opt_id;
@@ -953,7 +892,7 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
         }
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(ext->page) lv_dropdown_close(ddlist);
+        if(ext->list) lv_dropdown_close(ddlist);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         lv_style_int_t top = lv_obj_get_style_pad_top(ddlist, LV_DROPDOWN_PART_MAIN);
@@ -961,13 +900,13 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
         const lv_font_t * font = lv_obj_get_style_text_font(ddlist, LV_DROPDOWN_PART_MAIN);
         lv_obj_set_height(ddlist, top + bottom + lv_font_get_line_height(font));
 
-        if(ext->page) lv_obj_refresh_style(ext->page, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        if(ext->list) _lv_obj_refresh_style(ext->list, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
     else if(sign == LV_SIGNAL_CONTROL) {
 #if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN) {
-            if(ext->page == NULL) {
+            if(ext->list == NULL) {
                 lv_dropdown_open(ddlist);
             }
             else if(ext->sel_opt_id + 1 < ext->option_cnt) {
@@ -977,7 +916,7 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
         }
         else if(c == LV_KEY_LEFT || c == LV_KEY_UP) {
 
-            if(ext->page == NULL) {
+            if(ext->list == NULL) {
                 lv_dropdown_open(ddlist);
             }
             else if(ext->sel_opt_id > 0) {
@@ -1008,92 +947,40 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
  * @param param pointer to a signal specific variable
  * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
  */
-static lv_res_t lv_dropdown_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
+static lv_res_t lv_dropdown_page_signal(lv_obj_t * list, lv_signal_t sign, void * param)
 {
     lv_res_t res;
 
     /* Include the ancient signal function */
-    res = ancestor_page_signal(page, sign, param);
+    res = ancestor_list_signal(list, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
-    lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
-    lv_obj_t * ddlist = page_ext->ddlist;
+    lv_dropdown_list_ext_t * list_ext = lv_obj_get_ext_attr(list);
+    lv_obj_t * ddlist = list_ext->ddlist;
 
-    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        /* Make possible to draw on the full width of the background to redraw the selected rectangle
-         * when the ddlist is scrolled in fix height mode.
-         * (The scrollable is scrolled then "select rectangle" is drawn on the bg too)*/
-        lv_style_int_t left = lv_obj_get_style_pad_left(ddlist, LV_DROPDOWN_PART_LIST);
-        lv_style_int_t right = lv_obj_get_style_pad_right(ddlist, LV_DROPDOWN_PART_LIST);
-        lv_obj_t * scrl = lv_page_get_scrollable(page);
-        scrl->ext_draw_pad = LV_MATH_MAX3(scrl->ext_draw_pad, left, right);
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
-            page_release_handler(page);
+    if(sign == LV_SIGNAL_RELEASED) {
+        if(lv_indev_get_scroll_obj(lv_indev_get_act()) == NULL) {
+            list_release_handler(list);
         }
     }
     else if(sign == LV_SIGNAL_PRESSED) {
-        page_press_handler(page);
+        page_press_handler(list);
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
         lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-        ext->page  = NULL; /*The page is just being deleted*/
+        ext->list  = NULL; /*The list is just being deleted*/
     }
-
-    return res;
-}
-
-/**
- * Signal function of the drop down list's scrollable part
- * @param scrl pointer to a drop down list's scrollable part
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_dropdown_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_page_scrl_signal(scrl, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    lv_obj_t * page = lv_obj_get_parent(scrl);
-    lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
-    lv_obj_t * ddlist = page_ext->ddlist;
-    lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-
-    if(sign == LV_SIGNAL_RELEASED) {
-        if(lv_indev_is_scrolling(lv_indev_get_act()) == false) {
-            page_release_handler(page);
-        }
-    }
-    else if(sign == LV_SIGNAL_PRESSED) {
-        page_press_handler(page);
-    }
-    else if(sign == LV_SIGNAL_DRAG_BEGIN) {
+    else if(sign == LV_SIGNAL_SCROLL_BEGIN) {
+        lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
         ext->pr_opt_id = LV_DROPDOWN_PR_NONE;
-        lv_obj_invalidate(page);
+        lv_obj_invalidate(list);
     }
-    else  if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        /* Make possible to draw on the full width of the background to redraw the selected rectangle
-         * when the ddlist is scrolled in fix height mode.
-         * (The scrollable is scrolled then "select rectangle" is drawn on the bg too)*/
-        lv_style_int_t left = lv_obj_get_style_pad_left(ddlist, LV_DROPDOWN_PART_LIST);
-        lv_style_int_t right = lv_obj_get_style_pad_right(ddlist, LV_DROPDOWN_PART_LIST);
-        scrl->ext_draw_pad = LV_MATH_MAX3(scrl->ext_draw_pad, left, right);
-    }
-
     return res;
 }
 
-
 /**
  * Get the style descriptor of a part of the object
- * @param page pointer the object
+ * @param list pointer the object
  * @param part the part from `lv_dropdown_part_t`. (LV_DROPDOWN_PART_...)
  * @return pointer to the style descriptor of the specified part
  */
@@ -1109,10 +996,7 @@ static lv_style_list_t * lv_dropdown_get_style(lv_obj_t * ddlist, uint8_t part)
             style_dsc_p = &ddlist->style_list;
             break;
         case LV_DROPDOWN_PART_LIST:
-            style_dsc_p = &ext->style_page;
-            break;
-        case LV_DROPDOWN_PART_SCROLLBAR:
-            style_dsc_p = &ext->style_scrlbar;
+            style_dsc_p = &ext->style_list;
             break;
         case LV_DROPDOWN_PART_SELECTED:
             style_dsc_p = &ext->style_selected;
@@ -1127,12 +1011,12 @@ static lv_style_list_t * lv_dropdown_get_style(lv_obj_t * ddlist, uint8_t part)
 static void draw_box(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id, lv_state_t state)
 {
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    lv_obj_t * page = ext->page;
-    lv_state_t state_orig = page->state;
+    lv_obj_t * list = ext->list;
+    lv_state_t state_orig = list->state;
 
-    if(state != page->state) {
+    if(state != list->state) {
         _lv_obj_disable_style_caching(ddlist, true);
-        page->state = state;
+        list->state = state;
     }
 
     /*Draw a rectangle under the selected item*/
@@ -1148,15 +1032,15 @@ static void draw_box(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id
     rect_area.y1 -= line_space / 2;
 
     rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
-    rect_area.x1 = ext->page->coords.x1;
-    rect_area.x2 = ext->page->coords.x2;
+    rect_area.x1 = ext->list->coords.x1;
+    rect_area.x2 = ext->list->coords.x2;
 
     lv_draw_rect_dsc_t sel_rect;
     lv_draw_rect_dsc_init(&sel_rect);
     lv_obj_init_draw_rect_dsc(ddlist, LV_DROPDOWN_PART_SELECTED, &sel_rect);
     lv_draw_rect(&rect_area, clip_area, &sel_rect);
 
-    page->state = state_orig;
+    list->state = state_orig;
     _lv_obj_disable_style_caching(ddlist, false);
 }
 
@@ -1165,7 +1049,7 @@ static void draw_box(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id
 static void draw_box_label(lv_obj_t * ddlist, const lv_area_t * clip_area, uint16_t id, lv_state_t state)
 {
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    lv_obj_t * page = ext->page;
+    lv_obj_t * page = ext->list;
     lv_state_t state_orig = page->state;
 
     if(state != page->state) {
@@ -1178,7 +1062,7 @@ static void draw_box_label(lv_obj_t * ddlist, const lv_area_t * clip_area, uint1
     lv_obj_init_draw_label_dsc(ddlist, LV_DROPDOWN_PART_SELECTED, &label_dsc);
 
     label_dsc.line_space = lv_obj_get_style_text_line_space(ddlist,
-                                                            LV_DROPDOWN_PART_LIST);  /*Line space should come from the page*/
+                                                            LV_DROPDOWN_PART_LIST);  /*Line space should come from the list*/
 
     lv_obj_t * label = get_label(ddlist);
     if(label == NULL) return;
@@ -1210,12 +1094,12 @@ static void draw_box_label(lv_obj_t * ddlist, const lv_area_t * clip_area, uint1
 
 /**
  * Called when a drop down list is released to open it or set new option
- * @param page pointer to the drop down list's page
- * @return LV_RES_INV if the page is not being deleted in the user callback. Else LV_RES_OK
+ * @param list pointer to the drop down list's list
+ * @return LV_RES_INV if the list is not being deleted in the user callback. Else LV_RES_OK
  */
-static lv_res_t page_release_handler(lv_obj_t * page)
+static lv_res_t list_release_handler(lv_obj_t * page)
 {
-    lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
+    lv_dropdown_list_ext_t * page_ext = lv_obj_get_ext_attr(page);
     lv_obj_t * ddlist = page_ext->ddlist;
 
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
@@ -1243,19 +1127,19 @@ static lv_res_t page_release_handler(lv_obj_t * page)
     lv_dropdown_close(ddlist);
 
     /*Invalidate to refresh the text*/
-    if(ext->show_selected) lv_obj_invalidate(ddlist);
+    if(ext->text == NULL) lv_obj_invalidate(ddlist);
 
     uint32_t id  = ext->sel_opt_id; /*Just to use uint32_t in event data*/
     lv_res_t res = lv_event_send(ddlist, LV_EVENT_VALUE_CHANGED, &id);
     if(res != LV_RES_OK) return res;
-    if(ext->page == NULL) return LV_RES_INV;
+    if(ext->list == NULL) return LV_RES_INV;
 
     return LV_RES_OK;
 }
 
 static void page_press_handler(lv_obj_t * page)
 {
-    lv_dropdown_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
+    lv_dropdown_list_ext_t * page_ext = lv_obj_get_ext_attr(page);
     lv_obj_t * ddlist = page_ext->ddlist;
 
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
@@ -1306,29 +1190,27 @@ static void position_to_selected(lv_obj_t * ddlist)
 {
     lv_dropdown_ext_t * ext          = lv_obj_get_ext_attr(ddlist);
 
-    const lv_font_t * font         = lv_obj_get_style_text_font(ddlist, LV_DROPDOWN_PART_LIST);
-    lv_coord_t font_h              = lv_font_get_line_height(font);
-    lv_obj_t * scrl                = lv_page_get_scrollable(ext->page);
     lv_obj_t * label = get_label(ddlist);
     if(label == NULL) return;
 
-    lv_coord_t h = lv_obj_get_height(ext->page);
+    if(lv_obj_get_height(label) <= lv_obj_get_height_fit(ddlist)) return;
+
+    const lv_font_t * font         = lv_obj_get_style_text_font(ddlist, LV_DROPDOWN_PART_LIST);
+    lv_coord_t font_h              = lv_font_get_line_height(font);
     lv_style_int_t line_space = lv_obj_get_style_text_line_space(ddlist, LV_DROPDOWN_PART_LIST);
 
-    lv_coord_t line_y1 = ext->sel_opt_id * (font_h + line_space) + label->coords.y1 - scrl->coords.y1;
+    lv_coord_t line_y1 = ext->sel_opt_id * (font_h + line_space);
 
-    lv_obj_set_y(scrl, -line_y1 + (h - font_h) / 2);
-    lv_obj_invalidate(ext->page);
+    lv_obj_scroll_to_y(ext->list, line_y1, LV_ANIM_OFF);
+    lv_obj_invalidate(ext->list);
 }
 
-
-
 static lv_obj_t * get_label(const lv_obj_t * ddlist)
 {
     lv_dropdown_ext_t * ext = lv_obj_get_ext_attr(ddlist);
-    if(ext->page == NULL) return NULL;
+    if(ext->list == NULL) return NULL;
 
-    return lv_obj_get_child(lv_page_get_scrollable(ext->page), NULL);
+    return lv_obj_get_child(ext->list, NULL);
 }
 
 #endif
diff --git a/src/lv_widgets/lv_dropdown.h b/src/lv_widgets/lv_dropdown.h
index 87cae4387..c73e10d45 100644
--- a/src/lv_widgets/lv_dropdown.h
+++ b/src/lv_widgets/lv_dropdown.h
@@ -18,15 +18,11 @@ extern "C" {
 #if LV_USE_DROPDOWN != 0
 
 /*Testing of dependencies*/
-#if LV_USE_PAGE == 0
-#error "lv_ddlist: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE  1) "
-#endif
 
 #if LV_USE_LABEL == 0
 #error "lv_ddlist: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
 #endif
 
-#include "../lv_widgets/lv_page.h"
 #include "../lv_widgets/lv_label.h"
 
 /*********************
@@ -38,40 +34,29 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
-enum {
-    LV_DROPDOWN_DIR_DOWN,
-    LV_DROPDOWN_DIR_UP,
-    LV_DROPDOWN_DIR_LEFT,
-    LV_DROPDOWN_DIR_RIGHT,
-};
-
-typedef uint8_t lv_dropdown_dir_t;
-
 /*Data of drop down list*/
 typedef struct {
     /*New data for this type */
-    lv_obj_t * page;             /*The dropped down list*/
+    lv_obj_t * list;             /*The dropped down list*/
     const char * text;           /*Text to display on the ddlist's button*/
     const char * symbol;         /*Arrow or other icon when the drop-down list is closed*/
     char * options;
     lv_style_list_t style_selected; /*Style of the selected option*/
-    lv_style_list_t style_page;     /*Style of the dropped down list*/
-    lv_style_list_t style_scrlbar; /*Style of the scroll bar*/
+    lv_style_list_t style_list;     /*Style of the dropped down list*/
     lv_coord_t max_height;        /*Height of the ddlist when opened. (0: auto-size)*/
     uint16_t option_cnt;          /*Number of options*/
     uint16_t sel_opt_id;          /*Index of the currently selected option*/
     uint16_t sel_opt_id_orig;     /*Store the original index on focus*/
     uint16_t pr_opt_id;             /*Index of the currently pressed option*/
-    lv_dropdown_dir_t dir         : 2;
-    uint8_t show_selected  : 1;
+    lv_dir_t dir         : 4;
     uint8_t static_txt : 1;
 } lv_dropdown_ext_t;
 
 enum {
     LV_DROPDOWN_PART_MAIN = LV_OBJ_PART_MAIN,
-    LV_DROPDOWN_PART_LIST = _LV_OBJ_PART_REAL_LAST,
-    LV_DROPDOWN_PART_SCROLLBAR,
+    LV_DROPDOWN_PART_LIST,
     LV_DROPDOWN_PART_SELECTED,
+    _LV_DROPDOWN_PART_LAST
 };
 typedef uint8_t lv_dropdown_part_t;
 
@@ -99,7 +84,7 @@ lv_obj_t * lv_dropdown_create(lv_obj_t * par, const lv_obj_t * copy);
 void lv_dropdown_set_text(lv_obj_t * ddlist, const char * txt);
 
 /**
- * Clear any options in a drop down list.  Static or dynamic.
+ * Clear all options in a drop down list.  Static or dynamic.
  * @param ddlist pointer to drop down list object
  */
 void lv_dropdown_clear_options(lv_obj_t * ddlist);
@@ -138,9 +123,9 @@ void lv_dropdown_set_selected(lv_obj_t * ddlist, uint16_t sel_opt);
 /**
  * Set the direction of the a drop down list
  * @param ddlist pointer to a drop down list object
- * @param dir LV_DROPDOWN_DIR_LEF/RIGHT/TOP/BOTTOM
+ * @param dir LV_DIR_LEFT/RIGHT/TOP/BOTTOM
  */
-void lv_dropdown_set_dir(lv_obj_t * ddlist, lv_dropdown_dir_t dir);
+void lv_dropdown_set_dir(lv_obj_t * ddlist, lv_dir_t dir);
 
 /**
  * Set the maximal height for the drop down list
@@ -156,13 +141,6 @@ void lv_dropdown_set_max_height(lv_obj_t * ddlist, lv_coord_t h);
  */
 void lv_dropdown_set_symbol(lv_obj_t * ddlist, const char * symbol);
 
-/**
- * Set whether the ddlist highlight the last selected option and display its text or not
- * @param ddlist pointer to a drop down list object
- * @param show true/false
- */
-void lv_dropdown_set_show_selected(lv_obj_t * ddlist, bool show);
-
 /*=====================
  * Getter functions
  *====================*/
@@ -222,14 +200,7 @@ const char * lv_dropdown_get_symbol(lv_obj_t * ddlist);
  * @param ddlist pointer to drop down list object
  * @return the symbol or NULL if not enabled
  */
-lv_dropdown_dir_t lv_dropdown_get_dir(const lv_obj_t * ddlist);
-
-/**
- * Get whether the ddlist highlight the last selected option and display its text or not
- * @param ddlist pointer to a drop down list object
- * @return true/false
- */
-bool lv_dropdown_get_show_selected(lv_obj_t * ddlist);
+lv_dir_t lv_dropdown_get_dir(const lv_obj_t * ddlist);
 
 /*=====================
  * Other functions

From f3085bf19160485639b6d1b3ba1bcbd3f9d94a27 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 23 Sep 2020 18:50:57 +0200
Subject: [PATCH 40/84] style invalidation fixes

---
 src/lv_core/lv_obj.c         |  3 ++
 src/lv_core/lv_obj_style.c   | 75 +++++++++++++++++++-----------------
 src/lv_core/lv_obj_style.h   | 11 ++++++
 src/lv_widgets/lv_checkbox.c |  1 +
 4 files changed, 54 insertions(+), 36 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 929b825ef..7b9ac8849 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -778,6 +778,9 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
 
             }
         }
+        if(cmp_res == _LV_STYLE_STATE_CMP_VISUAL_DIFF) {
+            _lv_obj_invalidate_style_cache(obj, part, LV_STYLE_PROP_ALL);
+        }
 
     }
     if(cmp_res == _LV_STYLE_STATE_CMP_DIFF) _lv_obj_refresh_style(obj, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index c01b0a8b6..ceca453a0 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -92,7 +92,6 @@ static _lv_style_state_cmp_t style_snapshot_compare(style_snapshot_t * shot1, st
 static bool style_prop_is_cacheable(lv_style_property_t prop);
 static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop);
 static void update_style_cache_children(lv_obj_t * obj);
-static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
 #endif
 static void fade_anim_cb(lv_obj_t * obj, lv_anim_value_t v);
 static void fade_in_anim_ready(lv_anim_t * a);
@@ -307,6 +306,44 @@ void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis)
 }
 
 
+#if LV_STYLE_CACHE_LEVEL > 0
+
+/**
+ * Mark the object and all of it's children's style lists as invalid.
+ * The cache will be updated when a cached property asked nest time
+ * @param obj pointer to an object
+ */
+void _lv_obj_invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
+{
+    if(style_prop_is_cacheable(prop) == false) return;
+
+    if(part != LV_OBJ_PART_ALL) {
+        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+        if(list == NULL) return;
+        list->valid_cache = 0;
+    }
+    else {
+
+        for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
+            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+            if(list == NULL) break;
+            list->valid_cache = 0;
+        }
+        for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
+            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
+            if(list == NULL) break;
+            list->valid_cache = 0;
+        }
+    }
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    while(child) {
+        update_style_cache_children(child);
+        child = lv_obj_get_child(obj, child);
+    }
+}
+#endif /*LV_STYLE_CACHE_LEVEL >= 1*/
+
 /**
  * Get a style property of a part of an object in the object's current state.
  * If there is a running transitions it is taken into account
@@ -798,7 +835,7 @@ void _lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t pro
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 #if LV_STYLE_CACHE_LEVEL >= 1
-    invalidate_style_cache(obj, part, prop);
+    _lv_obj_invalidate_style_cache(obj, part, prop);
 #endif
 
     /*If a real style refresh is required*/
@@ -1481,40 +1518,6 @@ static void update_style_cache_children(lv_obj_t * obj)
 
 }
 
-/**
- * Mark the object and all of it's children's style lists as invalid.
- * The cache will be updated when a cached property asked nest time
- * @param obj pointer to an object
- */
-static void invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop)
-{
-    if(style_prop_is_cacheable(prop) == false) return;
-
-    if(part != LV_OBJ_PART_ALL) {
-        lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
-        if(list == NULL) return;
-        list->valid_cache = 0;
-    }
-    else {
-
-        for(part = 0; part < _LV_OBJ_PART_REAL_FIRST; part++) {
-            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
-            if(list == NULL) break;
-            list->valid_cache = 0;
-        }
-        for(part = _LV_OBJ_PART_REAL_FIRST; part < 0xFF; part++) {
-            lv_style_list_t * list = _lv_obj_get_style_list(obj, part);
-            if(list == NULL) break;
-            list->valid_cache = 0;
-        }
-    }
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    while(child) {
-        update_style_cache_children(child);
-        child = lv_obj_get_child(obj, child);
-    }
-}
 #endif /*LV_STYLE_CACHE_LEVEL >= 1*/
 
 
diff --git a/src/lv_core/lv_obj_style.h b/src/lv_core/lv_obj_style.h
index 7eecbb97d..598f240bf 100644
--- a/src/lv_core/lv_obj_style.h
+++ b/src/lv_core/lv_obj_style.h
@@ -127,6 +127,17 @@ lv_style_list_t * _lv_obj_get_style_list(const lv_obj_t * obj, uint8_t part);
  */
 void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
 
+
+#if LV_STYLE_CACHE_LEVEL > 0
+
+/**
+ * Mark the object and all of it's children's style lists as invalid.
+ * The cache will be updated when a cached property asked nest time
+ * @param obj pointer to an object
+ */
+void _lv_obj_invalidate_style_cache(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
+#endif
+
 /**
  * Get a style property of a part of an object in the object's current state.
  * If there is a running transitions it is taken into account
diff --git a/src/lv_widgets/lv_checkbox.c b/src/lv_widgets/lv_checkbox.c
index f577633b4..a8258d159 100644
--- a/src/lv_widgets/lv_checkbox.c
+++ b/src/lv_widgets/lv_checkbox.c
@@ -78,6 +78,7 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_label_set_text_static(cb, "Check box");
         lv_theme_apply(cb, LV_THEME_CHECKBOX);
         lv_obj_add_flag(cb, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_add_flag(cb, LV_OBJ_FLAG_CHECKABLE);
 
     }
     else {

From f5dc2e4248ca25a2dd385079136806ef81115e4c Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sun, 27 Sep 2020 22:10:08 +0200
Subject: [PATCH 41/84] rework roller

---
 src/lv_api_map.h              | 155 -------------
 src/lv_core/lv_indev.c        |  10 -
 src/lv_core/lv_indev_scroll.c |  31 +++
 src/lv_core/lv_indev_scroll.h |   8 +
 src/lv_core/lv_obj.c          |   2 +-
 src/lv_core/lv_obj.h          |   4 +-
 src/lv_core/lv_obj_pos.c      |   8 +-
 src/lv_core/lv_obj_scroll.c   |   3 -
 src/lv_misc/lv_anim.c         |   6 +-
 src/lv_widgets/lv_roller.c    | 401 +++++++++++++---------------------
 src/lv_widgets/lv_roller.h    |  47 +---
 11 files changed, 204 insertions(+), 471 deletions(-)

diff --git a/src/lv_api_map.h b/src/lv_api_map.h
index 23f7b8894..9ff34dc99 100644
--- a/src/lv_api_map.h
+++ b/src/lv_api_map.h
@@ -27,161 +27,6 @@ extern "C" {
  * GLOBAL PROTOTYPES
  **********************/
 
-/*---------------------
- * V6.0 COMPATIBILITY
- *--------------------*/
-#if LV_USE_API_EXTENSION_V6
-
-static inline void lv_task_once(lv_task_t * task)
-{
-    lv_task_set_repeat_count(task, 1);
-}
-
-#if LV_USE_CHECKBOX
-
-#define lv_checkbox_set_static_text lv_checkbox_set_text_static
-
-#endif
-
-#if LV_USE_CHART
-
-#define lv_chart_get_point_cnt lv_chart_get_point_count
-
-#endif
-
-
-#if LV_USE_DROPDOWN
-
-static inline void lv_dropdown_set_draw_arrow(lv_obj_t * ddlist, bool en)
-{
-    if(en) lv_dropdown_set_symbol(ddlist, LV_SYMBOL_DOWN);
-    else lv_dropdown_set_symbol(ddlist, NULL);
-}
-
-static inline bool lv_dropdown_get_draw_arrow(lv_obj_t * ddlist)
-{
-    if(lv_dropdown_get_symbol(ddlist)) return true;
-    else return false;
-}
-
-#define lv_dropdown_set_static_options lv_dropdown_set_options_static
-
-#endif
-
-#if LV_USE_BAR
-
-/**
- * Make the bar symmetric to zero. The indicator will grow from zero instead of the minimum
- * position.
- * @param bar pointer to a bar object
- * @param en true: enable disable symmetric behavior; false: disable
- * @deprecated As of v7.0, you should use `lv_bar_set_type` instead.
- */
-static inline void lv_bar_set_sym(lv_obj_t * bar, bool en)
-{
-    if(en)
-        lv_bar_set_type(bar, LV_BAR_TYPE_SYMMETRICAL);
-    else
-        lv_bar_set_type(bar, LV_BAR_TYPE_NORMAL);
-}
-
-/**
- * Get whether the bar is symmetric or not.
- * @param bar pointer to a bar object
- * @return true: symmetric is enabled; false: disable
- * @deprecated As of v7.0, you should use `lv_bar_get_type` instead.
- */
-static inline bool lv_bar_get_sym(lv_obj_t * bar)
-{
-    return lv_bar_get_type(bar) == LV_BAR_TYPE_SYMMETRICAL;
-}
-
-#endif
-
-#if LV_USE_LABEL
-
-#define lv_label_set_static_text lv_label_set_text_static
-
-#endif
-
-#if LV_USE_SLIDER
-
-/**
- * Make the slider symmetric to zero. The indicator will grow from zero instead of the minimum
- * position.
- * @param slider pointer to a bar object
- * @param en true: enable disable symmetric behavior; false: disable
- * @deprecated As of v7.0, you should use `lv_slider_set_type` instead.
- */
-static inline void lv_slider_set_sym(lv_obj_t * slider, bool en)
-{
-    lv_bar_set_sym(slider, en);
-}
-
-/**
- * Get whether the slider is symmetric or not.
- * @param slider pointer to a slider object
- * @return true: symmetric is enabled; false: disable
- * @deprecated As of v7.0, you should use `lv_slider_get_type` instead.
- */
-static inline bool lv_slider_get_sym(lv_obj_t * slider)
-{
-    return lv_bar_get_sym(slider);
-}
-
-#endif
-
-#if LV_USE_ROLLER
-
-/**
- * Set a fixed width for the roller.
- * @param roller pointer to a roller object
- * @param w width
- * @deprecated As of v7.0, you should use `lv_roller_set_auto_fit` and set the width normally instead.
- */
-static inline void lv_roller_set_fix_width(lv_obj_t * roller, lv_coord_t w)
-{
-    lv_roller_set_auto_fit(roller, false);
-    lv_obj_set_width(roller, w);
-}
-
-
-#endif
-
-
-#if LV_USE_PAGE
-#define lv_scrlbar_mode_t lv_scrollbar_mode_t
-
-#define LV_SCRLBAR_MODE_OFF    LV_SCROLLBAR_MODE_OFF
-#define LV_SCRLBAR_MODE_ON     LV_SCROLLBAR_MODE_ON
-#define LV_SCRLBAR_MODE_DRAG   LV_SCROLLBAR_MODE_DRAG
-#define LV_SCRLBAR_MODE_AUTO   LV_SCROLLBAR_MODE_AUTO
-#define LV_SCRLBAR_MODE_HIDE   LV_SCROLLBAR_MODE_HIDE
-#define LV_SCRLBAR_MODE_UNHIDE LV_SCROLLBAR_MODE_UNHIDE
-
-
-static inline void lv_page_set_scrlbar_mode(lv_obj_t * page, lv_scrlbar_mode_t sb_mode)
-{
-    lv_page_set_scrollbar_mode(page, sb_mode);
-}
-static inline lv_scrollbar_mode_t lv_page_get_scrlbar_mode(lv_obj_t * page)
-{
-    return lv_page_get_scrollbar_mode(page);
-}
-
-
-static inline lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
-{
-    return lv_page_get_scrollable(page);
-}
-#endif
-
-
-#endif /*LV_USE_API_EXTENSION_V6*/
-
-
-
-
 /*---------------------
  * V7.0 COMPATIBILITY
  *--------------------*/
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 788a3dda3..94055b903 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -991,16 +991,6 @@ static void indev_proc_release(lv_indev_proc_t * proc)
         lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
         if(indev_reset_check(proc)) return;
 
-
-        /*Send SCROLL_THROW_BEGIN signal and event*/
-        if(scroll_obj) {
-            lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_THROW_BEGIN, indev_act);
-            if(indev_reset_check(proc)) return;
-
-            lv_event_send(indev_obj_act, LV_EVENT_SCROLL_THROW_BEGIN, indev_act);
-            if(indev_reset_check(proc)) return;
-        }
-
         proc->types.pointer.act_obj = NULL;
         proc->pr_timestamp          = 0;
         proc->longpr_rep_timestamp  = 0;
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 817bc4155..2cedf81a7 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -353,6 +353,37 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
     }
 }
 
+/**
+ * Predict where would a scroll throw end
+ * @param indev pointer to an input device
+ * @param dir `LV_DIR_VER` or `LV_DIR_HOR`
+ * @return the difference compared to the current position when the throw would be finished
+ */
+lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir)
+{
+    if(indev == NULL) return 0;
+    lv_coord_t v;
+    switch(dir) {
+    case LV_DIR_VER:
+        v = indev->proc.types.pointer.scroll_throw_vect.y;
+        break;
+    case LV_DIR_HOR:
+        v = indev->proc.types.pointer.scroll_throw_vect.x;
+        break;
+    default:
+        return 0;
+    }
+
+    lv_coord_t scroll_throw = indev->driver.scroll_throw;
+    lv_coord_t sum = 0;
+    while(v) {
+        sum += v;
+        v = v * (100 - scroll_throw) / 100;
+    }
+
+    return sum;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_indev_scroll.h b/src/lv_core/lv_indev_scroll.h
index b43d608d5..600ddf0f2 100644
--- a/src/lv_core/lv_indev_scroll.h
+++ b/src/lv_core/lv_indev_scroll.h
@@ -40,6 +40,14 @@ void _lv_scroll_handler(lv_indev_proc_t * proc);
  */
 void _lv_scroll_throw_handler(lv_indev_proc_t * proc);
 
+/**
+ * Predict where would a scroll throw end
+ * @param indev pointer to an input device
+ * @param dir `LV_DIR_VER` or `LV_DIR_HOR`
+ * @return the difference compared to the current position when the throw would be finished
+ */
+lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 7b9ac8849..8121d0011 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1914,7 +1914,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
     }
     else if(sign == LV_SIGNAL_SCROLL) {
-        res = lv_event_send(obj, LV_EVENT_SCROLLED, NULL);
+        res = lv_event_send(obj, LV_EVENT_SCROLL, NULL);
         if(res != LV_RES_OK) return res;
     }
     else if(sign == LV_SIGNAL_SCROLL_END) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index b32cb8047..23d6f4f9b 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -92,9 +92,8 @@ enum {
     LV_EVENT_CLICKED,             /**< Called on release if not scrolled (regardless to long press)*/
     LV_EVENT_RELEASED,            /**< Called in every cases when the object has been released*/
     LV_EVENT_SCROLL_BEGIN,
-    LV_EVENT_SCROLL_THROW_BEGIN,
     LV_EVENT_SCROLL_END,
-    LV_EVENT_SCROLLED,
+    LV_EVENT_SCROLL,
     LV_EVENT_GESTURE,           /**< The object has been gesture*/
     LV_EVENT_KEY,
     LV_EVENT_FOCUSED,
@@ -142,7 +141,6 @@ enum {
     LV_SIGNAL_SCROLL_BEGIN,      /**< The scrolling has just begun  */
     LV_SIGNAL_SCROLL,            /**< The object has been scrolled */
     LV_SIGNAL_SCROLL_END,        /**< The scrolling has ended */
-    LV_SIGNAL_SCROLL_THROW_BEGIN,/**< Scroll throw started*/
     LV_SIGNAL_GESTURE,          /**< The object has been gesture*/
     LV_SIGNAL_LEAVE,            /**< Another object is clicked or chosen via an input device */
 
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 4516a8c96..42272e48d 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -98,7 +98,7 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
+    lv_obj_set_pos(obj, x, obj->y_set);
 }
 
 /**
@@ -110,7 +110,7 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
+    lv_obj_set_pos(obj, obj->x_set, y);
 }
 
 /**
@@ -175,7 +175,7 @@ void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_set_size(obj, w, lv_obj_get_height(obj));
+    lv_obj_set_size(obj, w, obj->h_set);
 }
 
 /**
@@ -187,7 +187,7 @@ void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_set_size(obj, lv_obj_get_width(obj), h);
+    lv_obj_set_size(obj, obj->w_set, h);
 }
 
 /**
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index bae5e6fe1..ef0c9e8c0 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -220,9 +220,6 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
  */
 lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 {
-    static uint32_t cnt = 0;
-    printf("scrl right: %d\n", cnt);
-    cnt++;
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     lv_coord_t child_res = LV_COORD_MIN;
diff --git a/src/lv_misc/lv_anim.c b/src/lv_misc/lv_anim.c
index 3794593d5..37e62a9f7 100644
--- a/src/lv_misc/lv_anim.c
+++ b/src/lv_misc/lv_anim.c
@@ -260,7 +260,7 @@ lv_anim_value_t lv_anim_path_ease_in(const lv_anim_path_t * path, const lv_anim_
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 100, 200, 1024);
+    int32_t step = _lv_bezier3(t, 0, 0, 1024 * 1 / 3, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
@@ -287,7 +287,7 @@ lv_anim_value_t lv_anim_path_ease_out(const lv_anim_path_t * path, const lv_anim
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 800, 900, 1024);
+    int32_t step = _lv_bezier3(t, 0, 1024 * 2 / 3, 1024, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
@@ -314,7 +314,7 @@ lv_anim_value_t lv_anim_path_ease_in_out(const lv_anim_path_t * path, const lv_a
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 100, 924, 1024);
+    int32_t step = _lv_bezier3(t, 0, 0, 1024, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
diff --git a/src/lv_widgets/lv_roller.c b/src/lv_widgets/lv_roller.c
index 702c7ccd1..c0f35174a 100644
--- a/src/lv_widgets/lv_roller.c
+++ b/src/lv_widgets/lv_roller.c
@@ -13,6 +13,8 @@
 #include "../lv_misc/lv_debug.h"
 #include "../lv_draw/lv_draw.h"
 #include "../lv_core/lv_group.h"
+#include "../lv_core/lv_indev.h"
+#include "../lv_core/lv_indev_scroll.h"
 #include "../lv_themes/lv_theme.h"
 
 /*********************
@@ -34,14 +36,11 @@
  **********************/
 static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part);
 static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param);
 static void refr_position(lv_obj_t * roller, lv_anim_enable_t animen);
-static void refr_height(lv_obj_t * roller);
-static void refr_width(lv_obj_t * roller);
 static lv_res_t release_handler(lv_obj_t * roller);
-static void inf_normalize(void * roller_scrl);
+static void inf_normalize(lv_obj_t * roller_scrl);
 static lv_obj_t * get_label(const lv_obj_t * roller);
 #if LV_USE_ANIMATION
     static void scroll_anim_ready_cb(lv_anim_t * a);
@@ -52,8 +51,8 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area);
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
+static lv_design_cb_t ancestor_design;
 static lv_design_cb_t ancestor_label_design;
-static lv_signal_cb_t ancestor_scrl_signal;
 
 /**********************
  *      MACROS
@@ -74,12 +73,12 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
     LV_LOG_TRACE("roller create started");
 
     /*Create the ancestor of roller*/
-    lv_obj_t * roller = lv_page_create(par, copy);
+    lv_obj_t * roller = lv_obj_create(par, copy);
     LV_ASSERT_MEM(roller);
     if(roller == NULL) return NULL;
 
-    if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(roller));
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(roller);
+    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(roller);
 
     /*Allocate the roller type specific extended data*/
     lv_roller_ext_t * ext = lv_obj_allocate_ext_attr(roller, sizeof(lv_roller_ext_t));
@@ -93,7 +92,6 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->option_cnt = 0;
     ext->sel_opt_id = 0;
     ext->sel_opt_id_ori = 0;
-    ext->auto_fit = 1;
     lv_style_list_init(&ext->style_sel);
 
     /*The signal and design functions are not copied so set them here*/
@@ -102,22 +100,18 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new roller roller*/
     if(copy == NULL) {
+        lv_obj_clear_flag(roller, LV_OBJ_FLAG_SCROLLABLE);
+        ext->anim_time = LV_ROLLER_DEF_ANIM_TIME;
+        lv_obj_set_width(roller, LV_SIZE_AUTO);
 
         lv_obj_t * label = lv_label_create(roller, NULL);
         lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
         if(ancestor_label_design == NULL) ancestor_label_design = lv_obj_get_design_cb(label);
         lv_obj_set_design_cb(label, lv_roller_label_design);
-        lv_obj_t * scrl = lv_page_get_scrollable(roller);
-        lv_obj_set_drag(scrl, true);
-        lv_page_set_scrollable_fit2(roller, LV_FIT_PARENT, LV_FIT_NONE); /*Height is specified directly*/
-        lv_roller_set_anim_time(roller, LV_ROLLER_DEF_ANIM_TIME);
+
         lv_roller_set_options(roller, "Option 1\nOption 2\nOption 3\nOption 4\nOption 5", LV_ROLLER_MODE_NORMAL);
 
-        lv_obj_set_signal_cb(scrl, lv_roller_scrl_signal);
-
-        lv_obj_clean_style_list(roller, LV_PAGE_PART_SCROLLABLE); /*Use a transparent scrollable*/
         lv_theme_apply(roller, LV_THEME_ROLLER);
-        refr_height(roller);
 
         lv_roller_set_visible_row_count(roller, 3);
     }
@@ -130,12 +124,9 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->option_cnt = copy_ext->option_cnt;
         ext->sel_opt_id = copy_ext->sel_opt_id;
         ext->sel_opt_id_ori = copy_ext->sel_opt_id;
-        ext->auto_fit = copy_ext->auto_fit;
-        lv_obj_t * scrl = lv_page_get_scrollable(roller);
-        lv_obj_set_signal_cb(scrl, lv_roller_scrl_signal);
 
         lv_style_list_copy(&ext->style_sel, &copy_ext->style_sel);
-        lv_obj_refresh_style(roller, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(roller, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("roller created");
@@ -194,12 +185,10 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
         ext->sel_opt_id     = ((LV_ROLLER_INF_PAGES / 2) + 0) * ext->option_cnt;
 
         ext->option_cnt = ext->option_cnt * LV_ROLLER_INF_PAGES;
+        inf_normalize(roller);
     }
 
     ext->sel_opt_id_ori = ext->sel_opt_id;
-
-    refr_height(roller);
-    refr_width(roller);
 }
 
 /**
@@ -215,7 +204,6 @@ void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
     if(label == NULL) return; /*Probably the roller is being deleted if the label is NULL.*/
 
     lv_label_set_align(label, align);
-    refr_width(roller); /*To set the correct label position*/
 }
 
 /**
@@ -272,23 +260,19 @@ void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt)
     lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
     lv_obj_set_height(roller, (lv_font_get_line_height(font) + line_space) * row_cnt);
 
-    refr_height(roller);
     refr_position(roller, LV_ANIM_OFF);
 }
 
 /**
- * Allow automatically setting the width of roller according to it's content.
+ * Get the animation time of the roller
  * @param roller pointer to a roller object
- * @param auto_fit true: enable auto fit
+ * @param the animation time in milliseconds
  */
-void lv_roller_set_auto_fit(lv_obj_t * roller, bool auto_fit)
+void lv_roller_set_anim_time(lv_obj_t * roller, uint32_t anim_time)
 {
-    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
-    ext->auto_fit = auto_fit;
-    refr_width(roller);
+    ext->anim_time = anim_time;
 }
-
 /*=====================
  * Getter functions
  *====================*/
@@ -376,18 +360,6 @@ lv_label_align_t lv_roller_get_align(const lv_obj_t * roller)
     return lv_label_get_align(get_label(roller));
 }
 
-/**
- * Get whether the auto fit option is enabled or not.
- * @param roller pointer to a roller object
- * @return true: auto fit is enabled
- */
-bool lv_roller_get_auto_fit(lv_obj_t * roller)
-{
-    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
-    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
-    return ext->auto_fit ? true : false;
-}
-
 /**
  * Get the options of a roller
  * @param roller pointer to roller object
@@ -400,6 +372,16 @@ const char * lv_roller_get_options(const lv_obj_t * roller)
     return lv_label_get_text(get_label(roller));
 }
 
+/**
+ * Get the animation time of the roller
+ * @param roller pointer to a roller object
+ * @return the animation time in milliseconds
+ */
+uint32_t lv_roller_get_anim_time(lv_obj_t * roller)
+{
+    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
+    return ext->anim_time;
+}
 
 /**********************
  *   STATIC FUNCTIONS
@@ -418,22 +400,21 @@ const char * lv_roller_get_options(const lv_obj_t * roller)
 static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode)
 {
     if(mode == LV_DESIGN_COVER_CHK) {
-        return LV_DESIGN_RES_NOT_COVER;
+        return ancestor_design(roller, clip_area, mode);
     }
     /*Draw the object*/
     else if(mode == LV_DESIGN_DRAW_MAIN) {
-        draw_bg(roller, clip_area);
+        ancestor_design(roller, clip_area, mode);
 
+        /*Draw the selected rectangle*/
         const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
         lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
         lv_coord_t font_h        = lv_font_get_line_height(font);
         lv_area_t rect_area;
-        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - line_space / 2;
-        if((font_h & 0x1) && (line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
+        rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - font_h - line_space) / 2;
         rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
         lv_area_t roller_coords;
         lv_obj_get_coords(roller, &roller_coords);
-        lv_obj_get_inner_coords(roller, &roller_coords);
 
         rect_area.x1 = roller_coords.x1;
         rect_area.x2 = roller_coords.x2;
@@ -453,8 +434,7 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
 
         /*Redraw the text on the selected area*/
         lv_area_t rect_area;
-        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - bg_font_h / 2 - label_dsc.line_space / 2;
-        if((bg_font_h & 0x1) && (label_dsc.line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
+        rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - bg_font_h - label_dsc.line_space) / 2;
         rect_area.y2 = rect_area.y1 + bg_font_h + label_dsc.line_space - 1;
         rect_area.x1 = roller->coords.x1;
         rect_area.x2 = roller->coords.x2;
@@ -504,6 +484,8 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
             label_dsc.flag |= LV_TXT_FLAG_EXPAND;
             lv_draw_label(&label_sel_area, &mask_sel, &label_dsc, lv_label_get_text(label), NULL);
         }
+
+        ancestor_design(roller, clip_area, mode);
     }
 
     return LV_DESIGN_RES_OK;
@@ -529,18 +511,17 @@ static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t
     else if(mode == LV_DESIGN_DRAW_MAIN) {
         /* Split the drawing of the label into  an upper (above the selected area)
          * and a lower (below the selected area)*/
-        lv_obj_t * roller = lv_obj_get_parent(lv_obj_get_parent(label));
+        lv_obj_t * roller = lv_obj_get_parent(label);
         const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
         lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
         lv_coord_t font_h        = lv_font_get_line_height(font);
 
         lv_area_t rect_area;
-        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - line_space / 2;
+        rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - font_h - line_space) / 2;
         if((font_h & 0x1) && (line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
         rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
         lv_area_t roller_coords;
         lv_obj_get_coords(roller, &roller_coords);
-        lv_obj_get_inner_coords(roller, &roller_coords);
 
         rect_area.x1 = roller_coords.x1;
         rect_area.x2 = roller_coords.x2;
@@ -575,44 +556,55 @@ static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t
  */
 static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param)
 {
-    lv_res_t res = LV_RES_OK;
+    lv_res_t res;
+
+    /* Include the ancient signal function */
+    res = ancestor_signal(roller, sign, param);
+    if(res != LV_RES_OK) return res;
+
+    int32_t id            = -1;
+    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
+
+    const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
+    lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
+    lv_coord_t font_h         = lv_font_get_line_height(font);
+
+    /* Include the ancient signal function */
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         info->result = lv_roller_get_style(roller, info->part);
         if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(roller, sign, param);
     }
-
-    /* Include the ancient signal function */
-    if(sign != LV_SIGNAL_CONTROL) { /*Don't let the page to scroll on keys*/
-        res = ancestor_signal(roller, sign, param);
-        if(res != LV_RES_OK) return res;
+    else if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
-
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
-    LV_UNUSED(ext);
-
-    if(sign == LV_SIGNAL_STYLE_CHG) {
+    else if(sign == LV_SIGNAL_STYLE_CHG) {
         lv_obj_t * label = get_label(roller);
         /*Be sure the label's style is updated before processing the roller*/
         if(label) lv_signal_send(label, LV_SIGNAL_STYLE_CHG, NULL);
-        refr_height(roller);
-        refr_width(roller);
         refr_position(roller, false);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-
         if(lv_obj_get_width(roller) != lv_area_get_width(param) ||
-           lv_obj_get_height(roller) != lv_area_get_height(param)) {
-#if LV_USE_ANIMATION
-            lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
-#endif
+           lv_obj_get_height(roller) != lv_area_get_height(param))
+        {
             refr_position(roller, false);
-            refr_width(roller);
         }
     }
+    else if(sign == LV_SIGNAL_PRESSED) {
+        ext->moved = 0;
+#if LV_USE_ANIMATION
+        lv_anim_del(get_label(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
+#endif
+    }
+    else if(sign == LV_SIGNAL_PRESSING) {
+        lv_indev_t * indev = lv_indev_get_act();
+        lv_point_t p;
+        lv_indev_get_vect(indev, &p);
+        lv_obj_t * label = get_label(roller);
+        lv_obj_set_y(label, lv_obj_get_y(label) + p.y);
+        if(p.y) ext->moved = 1;
+    }
     else if(sign == LV_SIGNAL_RELEASED) {
         release_handler(roller);
     }
@@ -672,8 +664,16 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
 #endif
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(roller, LV_ROLLER_PART_SELECTED);
+        _lv_obj_reset_style_list_no_refr(roller, LV_ROLLER_PART_SELECTED);
     }
+
+
+    /*Position the scrollable according to the new selected option*/
+    if(id != -1) {
+        refr_position(roller, LV_ANIM_ON);
+    }
+
+
     return res;
 }
 
@@ -704,77 +704,6 @@ static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part)
     return style_dsc_p;
 }
 
-/**
- * Signal function of the scrollable part of the roller.
- * @param roller_scrl pointer to the scrollable part of roller (page)
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_scrl_signal(roller_scrl, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    lv_obj_t * roller     = lv_obj_get_parent(roller_scrl);
-
-    /*On delete the ddlist signal deletes the label so nothing left to do here*/
-    lv_obj_t * label = get_label(roller);
-    if(label == NULL) return LV_RES_INV;
-
-    int32_t id            = -1;
-    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
-
-    const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
-    lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
-    lv_coord_t font_h              = lv_font_get_line_height(font);
-
-    if(sign == LV_SIGNAL_DRAG_END) {
-        /*If dragged then align the list to have an element in the middle*/
-        lv_coord_t label_y1   = label->coords.y1 - roller->coords.y1;
-        lv_coord_t label_unit = font_h + line_space;
-        lv_coord_t mid        = (roller->coords.y2 - roller->coords.y1) / 2;
-
-        id = (mid - label_y1 + line_space / 2) / label_unit;
-
-        if(id < 0) id = 0;
-        if(id >= ext->option_cnt) id = ext->option_cnt - 1;
-
-        ext->sel_opt_id     = id;
-        ext->sel_opt_id_ori = id;
-        res = lv_event_send(roller, LV_EVENT_VALUE_CHANGED, &id);
-        if(res != LV_RES_OK) return res;
-    }
-    /*If picked an option by clicking then set it*/
-    else if(sign == LV_SIGNAL_RELEASED) {
-        release_handler(roller);
-    }
-    else if(sign == LV_SIGNAL_PRESSED) {
-#if LV_USE_ANIMATION
-        lv_anim_del(roller_scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
-#endif
-    }
-    else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
-#if LV_USE_ANIMATION
-        lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
-#endif
-        refr_position(roller, false);
-        refr_width(roller);
-
-    }
-
-    /*Position the scrollable according to the new selected option*/
-    if(id != -1) {
-        refr_position(roller, LV_ANIM_ON);
-    }
-
-    return res;
-}
-
 /**
  * Draw a rectangle which has gradient on its top and bottom
  * @param roller pointer to a roller object
@@ -793,7 +722,6 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area)
     }
 
     /*With vertical gradient mirror it*/
-
     lv_area_t half_mask;
     lv_coord_t h = lv_obj_get_height(roller);
     bool union_ok;
@@ -837,45 +765,52 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area)
  */
 static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
 {
+    lv_obj_t * label = get_label(roller);
+    if(label == NULL) return;
+
 #if LV_USE_ANIMATION == 0
     anim_en = LV_ANIM_OFF;
 #endif
 
-    lv_obj_t * roller_scrl         = lv_page_get_scrollable(roller);
     lv_roller_ext_t * ext          = lv_obj_get_ext_attr(roller);
     const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
     lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
     lv_coord_t font_h              = lv_font_get_line_height(font);
-    lv_coord_t h                   = lv_obj_get_height(roller);
+    lv_coord_t h                   = lv_obj_get_height_fit(roller);
     uint16_t anim_time             = lv_roller_get_anim_time(roller);
 
     /* Normally the animation's `end_cb` sets correct position of the roller if infinite.
      * But without animations do it manually*/
     if(anim_en == LV_ANIM_OFF || anim_time == 0) {
-        inf_normalize(roller_scrl);
+        inf_normalize(roller);
     }
 
-    lv_obj_t * label = get_label(roller);
 
     int32_t id = ext->sel_opt_id;
-    lv_coord_t line_y1 = id * (font_h + line_space) + label->coords.y1 - roller_scrl->coords.y1;
-    lv_coord_t new_y = -line_y1 + (h - font_h) / 2;
+    lv_coord_t sel_y1 = id * (font_h + line_space);
+    lv_coord_t mid_y1 = h / 2 - font_h / 2;
+
+    lv_coord_t new_y = mid_y1 - sel_y1;
 
     if(anim_en == LV_ANIM_OFF || anim_time == 0) {
 #if LV_USE_ANIMATION
-        lv_anim_del(roller_scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
+        lv_anim_del(label, (lv_anim_exec_xcb_t)lv_obj_set_y);
 #endif
-        lv_obj_set_y(roller_scrl, new_y);
+        lv_obj_set_y(label, new_y);
     }
     else {
 #if LV_USE_ANIMATION
+        lv_anim_path_t path;
+        lv_anim_path_init(&path);
+        lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
         lv_anim_t a;
         lv_anim_init(&a);
-        lv_anim_set_var(&a, roller_scrl);
+        lv_anim_set_var(&a, label);
         lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
-        lv_anim_set_values(&a, lv_obj_get_y(roller_scrl), new_y);
+        lv_anim_set_values(&a, lv_obj_get_y(label), new_y);
         lv_anim_set_time(&a, anim_time);
         lv_anim_set_ready_cb(&a, scroll_anim_ready_cb);
+        lv_anim_set_path(&a, &path);
         lv_anim_start(&a);
 #endif
     }
@@ -885,12 +820,12 @@ static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
 static lv_res_t release_handler(lv_obj_t * roller)
 {
 
-    /*If there was dragging `DRAG_END` signal will refresh the position and update the selected option*/
-    if(lv_indev_is_scrolling(lv_indev_get_act())) return LV_RES_OK;
-
-    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
+    lv_obj_t * label = get_label(roller);
+    if(label == NULL) return LV_RES_OK;
 
     lv_indev_t * indev = lv_indev_get_act();
+    lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
+
 #if LV_USE_GROUP
     /*Leave edit mode once a new option is selected*/
     lv_indev_type_t indev_type = lv_indev_get_type(indev);
@@ -906,32 +841,50 @@ static lv_res_t release_handler(lv_obj_t * roller)
     }
 #endif
 
-    lv_obj_t * label = get_label(roller);
-    if(label == NULL) return LV_RES_OK;
-
     if(lv_indev_get_type(indev) == LV_INDEV_TYPE_POINTER || lv_indev_get_type(indev) == LV_INDEV_TYPE_BUTTON) {
         /*Search the clicked option (For KEYPAD and ENCODER the new value should be already set)*/
-        uint16_t new_opt  = 0;
-        lv_point_t p;
-        lv_indev_get_point(indev, &p);
-        p.y -= label->coords.y1;
-        p.x -= label->coords.x1;
-        uint32_t letter_i;
-        letter_i = lv_label_get_letter_on(label, &p);
+        int16_t new_opt  = -1;
+        if(ext->moved == 0) {
+            new_opt = 0;
+            lv_point_t p;
+            lv_indev_get_point(indev, &p);
+            p.y -= label->coords.y1;
+            p.x -= label->coords.x1;
+            uint32_t letter_i;
+            letter_i = lv_label_get_letter_on(label, &p);
 
-        const char * txt  = lv_label_get_text(label);
-        uint32_t i        = 0;
-        uint32_t i_prev   = 0;
+            const char * txt  = lv_label_get_text(label);
+            uint32_t i        = 0;
+            uint32_t i_prev   = 0;
 
-        uint32_t letter_cnt = 0;
-        for(letter_cnt = 0; letter_cnt < letter_i; letter_cnt++) {
-            uint32_t letter = _lv_txt_encoded_next(txt, &i);
-            /*Count he lines to reach the clicked letter. But ignore the last '\n' because it
-             * still belongs to the clicked line*/
-            if(letter == '\n' && i_prev != letter_i) new_opt++;
-            i_prev = i;
+            uint32_t letter_cnt = 0;
+            for(letter_cnt = 0; letter_cnt < letter_i; letter_cnt++) {
+                uint32_t letter = _lv_txt_encoded_next(txt, &i);
+                /*Count he lines to reach the clicked letter. But ignore the last '\n' because it
+                 * still belongs to the clicked line*/
+                if(letter == '\n' && i_prev != letter_i) new_opt++;
+                i_prev = i;
+            }
+        } else {
+            /*If dragged then align the list to have an element in the middle*/
+            const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
+            lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
+            lv_coord_t font_h              = lv_font_get_line_height(font);
+
+            lv_coord_t label_unit = font_h + line_space;
+            lv_coord_t mid        = roller->coords.y1 + (roller->coords.y2 - roller->coords.y1) / 2;
+            lv_coord_t label_y1 = label->coords.y1 + _lv_scroll_throw_predict(indev, LV_DIR_VER);
+            int32_t id = (mid - label_y1) / label_unit;
+
+            if(id < 0) id = 0;
+            if(id >= ext->option_cnt) id = ext->option_cnt - 1;
+
+            new_opt = id;
+        }
+
+        if(new_opt >= 0) {
+            lv_roller_set_selected(roller, new_opt, LV_ANIM_ON);
         }
-        lv_roller_set_selected(roller, new_opt, LV_ANIM_ON);
     }
 
     uint32_t id  = ext->sel_opt_id; /*Just to use uint32_t in event data*/
@@ -939,71 +892,12 @@ static lv_res_t release_handler(lv_obj_t * roller)
     return res;
 }
 
-static void refr_width(lv_obj_t * roller)
-{
-    lv_obj_t * label = get_label(roller);
-    if(label == NULL) return;
-
-    switch(lv_label_get_align(label)) {
-        case LV_LABEL_ALIGN_LEFT:
-            lv_obj_align(label, NULL, LV_ALIGN_IN_LEFT_MID, 0, 0);
-            break;
-        case LV_LABEL_ALIGN_CENTER:
-            lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0);
-            break;
-        case LV_LABEL_ALIGN_RIGHT:
-            lv_obj_align(label, NULL, LV_ALIGN_IN_RIGHT_MID, 0, 0);
-            break;
-    }
-
-
-    if(lv_roller_get_auto_fit(roller) == false) return;
-
-    lv_coord_t label_w = lv_obj_get_width(label);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(roller, LV_ROLLER_PART_BG);
-    lv_style_int_t right = lv_obj_get_style_pad_right(roller, LV_ROLLER_PART_BG);
-
-    const lv_font_t * base_font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
-    const lv_font_t * sel_font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_SELECTED);
-
-    /*The selected text might be larger to get its size*/
-    if(base_font != sel_font) {
-        lv_coord_t letter_sp = lv_obj_get_style_text_letter_space(roller, LV_ROLLER_PART_SELECTED);
-        lv_coord_t line_sp = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_SELECTED);
-        lv_point_t p;
-        _lv_txt_get_size(&p, lv_label_get_text(label), sel_font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_NONE);
-        if(label_w < p.x)label_w = p.x;
-    }
-
-    lv_obj_set_width(roller, label_w + left + right);
-}
-
-/**
- * Refresh the height of the roller and the scrollable
- * @param roller pointer to roller
- */
-static void refr_height(lv_obj_t * roller)
-{
-    lv_obj_t * label = get_label(roller);
-    if(label == NULL) return;
-
-    lv_obj_set_height(lv_page_get_scrollable(roller), lv_obj_get_height(label) + lv_obj_get_height(roller));
-
-#if LV_USE_ANIMATION
-    lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
-#endif
-    refr_position(roller, LV_ANIM_OFF);
-}
-
 /**
  * Set the middle page for the roller if infinite is enabled
- * @param scrl pointer to the roller's scrollable (lv_obj_t *)
+ * @param roller pointer to a roller object
  */
-static void inf_normalize(void * scrl)
+static void inf_normalize(lv_obj_t * roller)
 {
-    lv_obj_t * roller_scrl = (lv_obj_t *)scrl;
-    lv_obj_t * roller      = lv_obj_get_parent(roller_scrl);
     lv_roller_ext_t * ext  = lv_obj_get_ext_attr(roller);
 
     if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
@@ -1018,27 +912,28 @@ static void inf_normalize(void * scrl)
         const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
         lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
         lv_coord_t font_h              = lv_font_get_line_height(font);
-        lv_coord_t h                   = lv_obj_get_height(roller);
+        lv_coord_t h                   = lv_obj_get_height_fit(roller);
 
         lv_obj_t * label = get_label(roller);
 
-        lv_coord_t line_y1 = ext->sel_opt_id * (font_h + line_space) + label->coords.y1 - roller_scrl->coords.y1;
-        lv_coord_t new_y = -line_y1 + (h - font_h) / 2;
-        lv_obj_set_y(roller_scrl, new_y);
+
+        lv_coord_t sel_y1 = ext->sel_opt_id * (font_h + line_space);
+        lv_coord_t mid_y1 = h / 2 - font_h / 2;
+        lv_coord_t new_y = mid_y1 - sel_y1;
+        lv_obj_set_y(label, new_y);
     }
 }
 
 static lv_obj_t * get_label(const lv_obj_t * roller)
 {
-    lv_obj_t * scrl = lv_page_get_scrollable(roller);
-    if(scrl == NULL) return NULL;   /*The roller is being deleted, the scrollable already not exists*/
-    return lv_obj_get_child(scrl, NULL);
+    return lv_obj_get_child(roller, NULL);
 }
 
 #if LV_USE_ANIMATION
 static void scroll_anim_ready_cb(lv_anim_t * a)
 {
-    inf_normalize(a->var);
+    lv_obj_t * roller = lv_obj_get_parent(a->var); /*The label is animated*/
+    inf_normalize(roller);
 }
 #endif
 
diff --git a/src/lv_widgets/lv_roller.h b/src/lv_widgets/lv_roller.h
index a71e1c551..9683504c6 100644
--- a/src/lv_widgets/lv_roller.h
+++ b/src/lv_widgets/lv_roller.h
@@ -17,13 +17,7 @@ extern "C" {
 
 #if LV_USE_ROLLER != 0
 
-/*Testing of dependencies*/
-#if LV_USE_PAGE == 0
-#error "lv_roller: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE 1) "
-#endif
-
 #include "../lv_core/lv_obj.h"
-#include "lv_page.h"
 #include "lv_label.h"
 
 /*********************
@@ -46,20 +40,21 @@ typedef uint8_t lv_roller_mode_t;
 
 /*Data of roller*/
 typedef struct {
-    lv_page_ext_t page; /*Ext. of ancestor*/
+    /*No inherited ext.*/ /*Ext. of ancestor*/
 
     /*New data for this type */
     lv_style_list_t style_sel; /*Style of the selected option*/
     uint16_t option_cnt;          /*Number of options*/
     uint16_t sel_opt_id;          /*Index of the current option*/
     uint16_t sel_opt_id_ori;      /*Store the original index on focus*/
+    uint32_t anim_time;
     lv_roller_mode_t mode : 1;
-    uint8_t auto_fit : 1;         /*1: Automatically set the width*/
+    uint32_t moved : 1;
 } lv_roller_ext_t;
 
 enum {
-    LV_ROLLER_PART_BG = LV_PAGE_PART_BG,
-    LV_ROLLER_PART_SELECTED = _LV_PAGE_PART_VIRTUAL_LAST,
+    LV_ROLLER_PART_BG = LV_OBJ_PART_MAIN,
+    LV_ROLLER_PART_SELECTED,
     _LV_ROLLER_PART_VIRTUAL_LAST,
 };
 typedef uint8_t lv_roller_part_t;
@@ -111,21 +106,11 @@ void lv_roller_set_selected(lv_obj_t * roller, uint16_t sel_opt, lv_anim_enable_
 void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt);
 
 /**
- * Allow automatically setting the width of roller according to it's content.
+ * Get the animation time of the roller
  * @param roller pointer to a roller object
- * @param auto_fit true: enable auto fit
+ * @param the animation time in milliseconds
  */
-void lv_roller_set_auto_fit(lv_obj_t * roller, bool auto_fit);
-
-/**
- * Set the open/close animation time.
- * @param roller pointer to a roller object
- * @param anim_time: open/close animation time [ms]
- */
-static inline void lv_roller_set_anim_time(lv_obj_t * roller, uint16_t anim_time)
-{
-    lv_page_set_anim_time(roller, anim_time);
-}
+void lv_roller_set_anim_time(lv_obj_t * roller, uint32_t anim_time);
 
 /*=====================
  * Getter functions
@@ -159,13 +144,6 @@ void lv_roller_get_selected_str(const lv_obj_t * roller, char * buf, uint32_t bu
  */
 lv_label_align_t lv_roller_get_align(const lv_obj_t * roller);
 
-/**
- * Get whether the auto fit option is enabled or not.
- * @param roller pointer to a roller object
- * @return true: auto fit is enabled
- */
-bool lv_roller_get_auto_fit(lv_obj_t * roller);
-
 /**
  * Get the options of a roller
  * @param roller pointer to roller object
@@ -173,15 +151,6 @@ bool lv_roller_get_auto_fit(lv_obj_t * roller);
  */
 const char * lv_roller_get_options(const lv_obj_t * roller);
 
-/**
- * Get the open/close animation time.
- * @param roller pointer to a roller
- * @return open/close animation time [ms]
- */
-static inline uint16_t lv_roller_get_anim_time(const lv_obj_t * roller)
-{
-    return lv_page_get_anim_time(roller);
-}
 
 
 /**********************

From c474d6d3a664ee889141edaae2b094fb30aa66f4 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 28 Sep 2020 10:42:36 +0200
Subject: [PATCH 42/84] add self-size support

---
 src/lv_core/lv_grid.c       |  10 ++-
 src/lv_core/lv_obj.h        |   1 +
 src/lv_core/lv_obj_pos.c    |   8 +-
 src/lv_core/lv_obj_scroll.c |  11 ++-
 src/lv_widgets/lv_roller.c  | 143 +++++++++++++++++++-----------------
 5 files changed, 100 insertions(+), 73 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index d8e8d3c8a..cd0170d1a 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -385,7 +385,10 @@ static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
     while(child) {
         if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
             lv_coord_t w;
-            if(_GRID_GET_CELL_FLAG(child->x_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  &w, NULL);
+            if(_GRID_GET_CELL_FLAG(child->x_set) == LV_GRID_STRETCH) {
+                lv_obj_scroll_to_x(child, 0, LV_ANIM_OFF);
+                _lv_obj_calc_auto_size(child,  &w, NULL);
+            }
             else w = lv_obj_get_width(child);
             calc->w[col_i] = LV_MATH_MAX(calc->w[col_i], w);
             row_i++;
@@ -416,7 +419,10 @@ static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
     while(child) {
         if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
             lv_coord_t h;
-            if(_GRID_GET_CELL_FLAG(child->y_set) == LV_GRID_STRETCH) _lv_obj_calc_auto_size(child,  NULL, &h);
+            if(_GRID_GET_CELL_FLAG(child->y_set) == LV_GRID_STRETCH) {
+                lv_obj_scroll_to_y(child, 0, LV_ANIM_OFF);
+                _lv_obj_calc_auto_size(child,  NULL, &h);
+            }
             else h = lv_obj_get_height(child);
             calc->h[row_i] = LV_MATH_MAX(calc->h[row_i], h);
             col_i++;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 23d6f4f9b..a6ed06d50 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -129,6 +129,7 @@ enum {
     LV_SIGNAL_REFR_EXT_DRAW_PAD, /**< Object's extra padding has changed */
     LV_SIGNAL_GET_TYPE,          /**< LVGL needs to retrieve the object's type */
     LV_SIGNAL_GET_STYLE,         /**< Get the style of an object*/
+    LV_SIGNAL_GET_SELF_SIZE,     /**< Get the internal size of a widget*/
 
     /*Input device related*/
     LV_SIGNAL_HIT_TEST,          /**< Advanced hit-testing */
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 42272e48d..d3fefad13 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -147,6 +147,10 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     bool x_auto = obj->w_set == LV_SIZE_AUTO ? true : false;
     bool y_auto = obj->h_set == LV_SIZE_AUTO ? true : false;
 
+    /*Be sure the object is not scrolled when it has auto size*/
+    if(x_auto) lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+    if(y_auto) lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+
     lv_coord_t auto_w;
     lv_coord_t auto_h;
     if(x_auto && y_auto) {
@@ -471,17 +475,15 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
     lv_coord_t children_w = 0;
     lv_coord_t children_h = 0;
     if(w_out) {
-        lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
         lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
         lv_coord_t scroll_left = lv_obj_get_scroll_left(obj);
         children_w = lv_obj_get_width(obj) + scroll_right + scroll_left;
     }
 
     if(h_out) {
-        lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
         lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
         lv_coord_t scroll_top = lv_obj_get_scroll_top(obj);
-        children_h = lv_obj_get_height(obj) + scroll_bottom + scroll_top ;
+        children_h = lv_obj_get_height(obj) + scroll_bottom + scroll_top;
     }
 
     /*auto_size = max(gird_size, children_size)*/
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index ef0c9e8c0..0954d62e0 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -234,7 +234,16 @@ lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 
     }
 
-    return child_res - obj->coords.x2 + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+
+    child_res -= (obj->coords.x2 - pad_right);
+
+    lv_point_t p = {0, 0};
+    lv_signal_send(obj, LV_SIGNAL_GET_SELF_SIZE, &p);
+    p.x = p.x - (lv_obj_get_width(obj) - pad_right - pad_left);
+    p.x += obj->scroll.x;
+    return LV_MATH_MAX(child_res, p.x);
 }
 
 /**********************
diff --git a/src/lv_widgets/lv_roller.c b/src/lv_widgets/lv_roller.c
index c0f35174a..8fc8eb575 100644
--- a/src/lv_widgets/lv_roller.c
+++ b/src/lv_widgets/lv_roller.c
@@ -38,20 +38,22 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
 static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part);
 static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param);
+static lv_res_t lv_roller_label_signal(lv_obj_t * label, lv_signal_t sign, void * param);
 static void refr_position(lv_obj_t * roller, lv_anim_enable_t animen);
 static lv_res_t release_handler(lv_obj_t * roller);
 static void inf_normalize(lv_obj_t * roller_scrl);
 static lv_obj_t * get_label(const lv_obj_t * roller);
+static lv_coord_t get_selected_label_width(const lv_obj_t * roller);
 #if LV_USE_ANIMATION
     static void scroll_anim_ready_cb(lv_anim_t * a);
 #endif
-static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
 static lv_design_cb_t ancestor_design;
+static lv_signal_cb_t ancestor_label_signal;
 static lv_design_cb_t ancestor_label_design;
 
 /**********************
@@ -95,8 +97,6 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
     lv_style_list_init(&ext->style_sel);
 
     /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(roller, lv_roller_signal);
-    lv_obj_set_design_cb(roller, lv_roller_design);
 
     /*Init the new roller roller*/
     if(copy == NULL) {
@@ -106,8 +106,14 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
 
         lv_obj_t * label = lv_label_create(roller, NULL);
         lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+
         if(ancestor_label_design == NULL) ancestor_label_design = lv_obj_get_design_cb(label);
+        if(ancestor_label_signal == NULL) ancestor_label_signal = lv_obj_get_signal_cb(label);
         lv_obj_set_design_cb(label, lv_roller_label_design);
+        lv_obj_set_signal_cb(label, lv_roller_label_signal);
+
+        lv_obj_set_signal_cb(roller, lv_roller_signal);
+        lv_obj_set_design_cb(roller, lv_roller_design);
 
         lv_roller_set_options(roller, "Option 1\nOption 2\nOption 3\nOption 4\nOption 5", LV_ROLLER_MODE_NORMAL);
 
@@ -117,7 +123,7 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
     }
     /*Copy an existing roller*/
     else {
-        lv_label_create(roller, get_label(copy));
+        lv_obj_t * label = lv_label_create(roller, get_label(copy));
 
         lv_roller_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
         ext->mode = copy_ext->mode;
@@ -125,6 +131,12 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->sel_opt_id = copy_ext->sel_opt_id;
         ext->sel_opt_id_ori = copy_ext->sel_opt_id;
 
+        lv_obj_set_design_cb(label, lv_roller_label_design);
+        lv_obj_set_signal_cb(label, lv_roller_label_signal);
+
+        lv_obj_set_signal_cb(roller, lv_roller_signal);
+        lv_obj_set_design_cb(roller, lv_roller_design);
+
         lv_style_list_copy(&ext->style_sel, &copy_ext->style_sel);
         _lv_obj_refresh_style(roller, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
@@ -189,6 +201,10 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
     }
 
     ext->sel_opt_id_ori = ext->sel_opt_id;
+
+    /*If the selected text has larger font the label needs some extra draw padding to draw it.*/
+    _lv_obj_refresh_ext_draw_pad(label);
+
 }
 
 /**
@@ -204,6 +220,7 @@ void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
     if(label == NULL) return; /*Probably the roller is being deleted if the label is NULL.*/
 
     lv_label_set_align(label, align);
+    refr_position(roller, LV_ANIM_OFF);
 }
 
 /**
@@ -562,13 +579,8 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
     res = ancestor_signal(roller, sign, param);
     if(res != LV_RES_OK) return res;
 
-    int32_t id            = -1;
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
 
-    const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
-    lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
-    lv_coord_t font_h         = lv_font_get_line_height(font);
-
     /* Include the ancient signal function */
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
@@ -578,10 +590,15 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
     else if(sign == LV_SIGNAL_GET_TYPE) {
         return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
+    else if(sign == LV_SIGNAL_GET_SELF_SIZE) {
+        lv_point_t * p = param;
+        p->x =  get_selected_label_width(roller);
+    }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         lv_obj_t * label = get_label(roller);
         /*Be sure the label's style is updated before processing the roller*/
         if(label) lv_signal_send(label, LV_SIGNAL_STYLE_CHG, NULL);
+        lv_obj_set_width(roller, roller->w_set);
         refr_position(roller, false);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
@@ -667,13 +684,32 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
         _lv_obj_reset_style_list_no_refr(roller, LV_ROLLER_PART_SELECTED);
     }
 
+    return res;
+}
 
-    /*Position the scrollable according to the new selected option*/
-    if(id != -1) {
-        refr_position(roller, LV_ANIM_ON);
+/**
+ * Signal function of the roller's label
+ * @param label pointer to a roller's label object
+ * @param sign a signal type from lv_signal_t enum
+ * @param param pointer to a signal specific variable
+ * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
+ */
+static lv_res_t lv_roller_label_signal(lv_obj_t * label, lv_signal_t sign, void * param)
+{
+    lv_res_t res;
+
+    /* Include the ancient signal function */
+    res = ancestor_label_signal(label, sign, param);
+    if(res != LV_RES_OK) return res;
+
+    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
+        /*If the selected text has a larger font it needs some extra space to draw it*/
+        lv_obj_t * roller = lv_obj_get_parent(label);
+        lv_coord_t sel_w = get_selected_label_width(roller);
+        lv_coord_t label_w = lv_obj_get_width(label);
+        label->ext_draw_pad = LV_MATH_MAX(label->ext_draw_pad, sel_w - label_w);
     }
 
-
     return res;
 }
 
@@ -704,60 +740,6 @@ static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part)
     return style_dsc_p;
 }
 
-/**
- * Draw a rectangle which has gradient on its top and bottom
- * @param roller pointer to a roller object
- * @param clip_area pointer to the current mask (from the design function)
- */
-static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area)
-{
-    lv_draw_rect_dsc_t bg_dsc;
-    lv_draw_rect_dsc_init(&bg_dsc);
-    lv_obj_init_draw_rect_dsc(roller, LV_ROLLER_PART_BG, &bg_dsc);
-
-    /*With non-vertical gradient simply draw the background*/
-    if(bg_dsc.bg_grad_dir == LV_GRAD_DIR_NONE) {
-        lv_draw_rect(&roller->coords, clip_area, &bg_dsc);
-        return;
-    }
-
-    /*With vertical gradient mirror it*/
-    lv_area_t half_mask;
-    lv_coord_t h = lv_obj_get_height(roller);
-    bool union_ok;
-
-    lv_area_copy(&half_mask, &roller->coords);
-    half_mask.x1 -= roller->ext_draw_pad; /*Add ext size too (e.g. because of shadow draw) */
-    half_mask.x2 += roller->ext_draw_pad;
-    half_mask.y1 -= roller->ext_draw_pad;
-    half_mask.y2 = roller->coords.y1 + h / 2;
-
-    union_ok = _lv_area_intersect(&half_mask, &half_mask, clip_area);
-    bg_dsc.bg_main_color_stop = bg_dsc.bg_main_color_stop / 2;
-    bg_dsc.bg_grad_color_stop = 128 - (255 - bg_dsc.bg_grad_color_stop) / 2;
-    if(union_ok) {
-        lv_draw_rect(&roller->coords, &half_mask, &bg_dsc);
-    }
-
-    lv_area_copy(&half_mask, &roller->coords);
-    half_mask.x1 -= roller->ext_draw_pad; /*Revert ext. size adding*/
-    half_mask.x2 += roller->ext_draw_pad;
-    half_mask.y1 = roller->coords.y1 + h / 2;
-    half_mask.y2 += roller->ext_draw_pad;
-
-    union_ok = _lv_area_intersect(&half_mask, &half_mask, clip_area);
-    if(union_ok) {
-        lv_color_t c = bg_dsc.bg_color;
-        bg_dsc.bg_color = bg_dsc.bg_grad_color;
-        bg_dsc.bg_grad_color = c;
-
-        bg_dsc.bg_main_color_stop += 127;
-        bg_dsc.bg_grad_color_stop += 127;
-        lv_draw_rect(&roller->coords, &half_mask, &bg_dsc);
-    }
-}
-
-
 /**
  * Refresh the position of the roller. It uses the id stored in: ext->ddlist.selected_option_id
  * @param roller pointer to a roller object
@@ -772,6 +754,19 @@ static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
     anim_en = LV_ANIM_OFF;
 #endif
 
+    lv_label_align_t align = lv_label_get_align(label);
+    switch(align) {
+    case LV_LABEL_ALIGN_CENTER:
+        lv_obj_set_x(label, (lv_obj_get_width_fit(roller) - lv_obj_get_width(label)) / 2);
+        break;
+    case LV_LABEL_ALIGN_RIGHT:
+        lv_obj_set_x(label, lv_obj_get_width_fit(roller) - lv_obj_get_width(label));
+        break;
+    case LV_LABEL_ALIGN_LEFT:
+        lv_obj_set_x(label, 0);
+        break;
+    }
+
     lv_roller_ext_t * ext          = lv_obj_get_ext_attr(roller);
     const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
     lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
@@ -929,6 +924,20 @@ static lv_obj_t * get_label(const lv_obj_t * roller)
     return lv_obj_get_child(roller, NULL);
 }
 
+
+static lv_coord_t get_selected_label_width(const lv_obj_t * roller)
+{
+    lv_obj_t * label = get_label(roller);
+    if(label == NULL) return 0;
+
+    const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_SELECTED);
+    lv_style_int_t letter_space = lv_obj_get_style_text_letter_space(roller, LV_ROLLER_PART_SELECTED);
+    const char * txt = lv_label_get_text(label);
+    lv_point_t size;
+    _lv_txt_get_size(&size, txt, font, letter_space, 0, LV_COORD_MAX,  LV_TXT_FLAG_NONE);
+    return size.x;
+}
+
 #if LV_USE_ANIMATION
 static void scroll_anim_ready_cb(lv_anim_t * a)
 {

From 132e79fa428f0f428a1015b0272dce94a6e4a442 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 29 Sep 2020 14:26:35 +0200
Subject: [PATCH 43/84] rework checkbox and add LV_SIGNAL_SELF_SIZE

---
 src/lv_core/lv_obj_pos.c          |  37 ++++++++
 src/lv_core/lv_obj_pos.h          |  21 +++++
 src/lv_core/lv_obj_scroll.c       |  26 ++++--
 src/lv_core/lv_obj_scroll.h       |   4 +-
 src/lv_themes/lv_theme_material.c |   3 -
 src/lv_widgets/lv_canvas.c        |   7 +-
 src/lv_widgets/lv_checkbox.c      | 147 ++++++++++++++++++++++++++++--
 src/lv_widgets/lv_checkbox.h      |  58 ++----------
 8 files changed, 226 insertions(+), 77 deletions(-)

diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index d3fefad13..e1a719fe9 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -444,6 +444,43 @@ lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
     return lv_obj_get_width(obj) + mleft + mright;
 }
 
+/**
+ * Get the width of the virtual content of an object
+ * @param obj pointer to an objects
+ * @return the width of the virtually drawn content
+ */
+lv_coord_t _lv_obj_get_self_width(lv_obj_t * obj)
+{
+    lv_point_t p = {0, LV_COORD_MIN};
+    lv_signal_send((lv_obj_t * )obj, LV_SIGNAL_GET_SELF_SIZE, &p);
+    return p.x;
+}
+
+/**
+ * Get the height of the virtual content of an object
+ * @param obj pointer to an objects
+ * @return the width of the virtually drawn content
+ */
+lv_coord_t _lv_obj_get_self_height(lv_obj_t * obj)
+{
+    lv_point_t p = {LV_COORD_MIN, 0};
+    lv_signal_send((lv_obj_t * )obj, LV_SIGNAL_GET_SELF_SIZE, &p);
+    return p.y;
+}
+
+/**
+ * Handle if the size of the internal (virtual) content of an object has changed.
+ * @param obj pointer to an object
+ * @return false: nothing happened; true: refresh happened
+ */
+bool _lv_obj_handle_self_size_chg(lv_obj_t * obj)
+{
+    if(obj->w_set != LV_SIZE_AUTO && obj->h_set == LV_SIZE_AUTO) return false;
+
+    lv_obj_set_size(obj, obj->w_set, obj->h_set);
+    return true;
+}
+
 /**
  * Calculate the "auto size". It's `auto_size = max(gird_size, children_size, self_size)`
  * @param obj pointer to an object
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
index fa763d5bc..0f440f496 100644
--- a/src/lv_core/lv_obj_pos.h
+++ b/src/lv_core/lv_obj_pos.h
@@ -198,6 +198,27 @@ lv_coord_t lv_obj_get_height_margin(struct _lv_obj_t * obj);
  */
 lv_coord_t lv_obj_get_width_margin(struct _lv_obj_t * obj);
 
+/**
+ * Get the width of the virtual content of an object
+ * @param obj pointer to an objects
+ * @return the width of the virtually drawn content
+ */
+lv_coord_t _lv_obj_get_self_width(lv_obj_t * obj);
+
+/**
+ * Get the height of the virtual content of an object
+ * @param obj pointer to an objects
+ * @return the width of the virtually drawn content
+ */
+lv_coord_t _lv_obj_get_self_height(lv_obj_t * obj);
+
+/**
+ * Handle if the size of the internal (virtual) content of an object has changed.
+ * @param obj pointer to an object
+ * @return false: nothing happened; true: refresh happened
+ */
+bool _lv_obj_handle_self_size_chg(lv_obj_t * obj);
+
 /**
  * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
  * @param obj pointer to an object
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 0954d62e0..1e6547ad9 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -179,7 +179,7 @@ lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -196,6 +196,18 @@ lv_coord_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
         child_res = y2;
     }
 
+
+    lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+
+    child_res -= (obj->coords.y2 - pad_bottom);
+
+    lv_coord_t self_h = _lv_obj_get_self_height(obj);
+    self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
+    self_h += obj->scroll.y;
+    return LV_MATH_MAX(child_res, self_h);
+
+
     return child_res - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
 }
 
@@ -218,7 +230,7 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -239,11 +251,11 @@ lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 
     child_res -= (obj->coords.x2 - pad_right);
 
-    lv_point_t p = {0, 0};
-    lv_signal_send(obj, LV_SIGNAL_GET_SELF_SIZE, &p);
-    p.x = p.x - (lv_obj_get_width(obj) - pad_right - pad_left);
-    p.x += obj->scroll.x;
-    return LV_MATH_MAX(child_res, p.x);
+    lv_coord_t self_w = _lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+    self_w += obj->scroll.x;
+
+    return LV_MATH_MAX(child_res, self_w);
 }
 
 /**********************
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index bb7987132..191d7c94e 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -119,7 +119,7 @@ lv_coord_t lv_obj_get_scroll_top(const struct _lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_bottom(const struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_bottom(struct _lv_obj_t * obj);
 
 
 /**
@@ -138,7 +138,7 @@ lv_coord_t lv_obj_get_scroll_left(const struct _lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_right(const struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
 
 
 /**********************
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 0bda77ec6..1dd0b110c 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -626,9 +626,6 @@ static void checkbox_init(void)
 #if LV_USE_CHECKBOX != 0
     style_init_reset(&styles->cb_bg);
     lv_style_set_radius(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(4));
-    lv_style_set_pad_left(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(30));
-    lv_style_set_pad_top(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(3));
-    lv_style_set_pad_bottom(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(3));
     lv_style_set_outline_color(&styles->cb_bg, LV_STATE_DEFAULT, theme.color_primary);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_DEFAULT, LV_OPA_TRANSP);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_FOCUSED, LV_OPA_50);
diff --git a/src/lv_widgets/lv_canvas.c b/src/lv_widgets/lv_canvas.c
index 14fb5e023..1c3c8784a 100644
--- a/src/lv_widgets/lv_canvas.c
+++ b/src/lv_widgets/lv_canvas.c
@@ -1108,9 +1108,10 @@ static lv_res_t lv_canvas_signal(lv_obj_t * canvas, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(canvas, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
     }
 
diff --git a/src/lv_widgets/lv_checkbox.c b/src/lv_widgets/lv_checkbox.c
index a8258d159..0da9ab5f5 100644
--- a/src/lv_widgets/lv_checkbox.c
+++ b/src/lv_widgets/lv_checkbox.c
@@ -12,6 +12,7 @@
 #include "../lv_misc/lv_debug.h"
 #include "../lv_core/lv_group.h"
 #include "../lv_themes/lv_theme.h"
+#include "lv_label.h"
 
 /*********************
  *      DEFINES
@@ -54,7 +55,7 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
     LV_LOG_TRACE("check box create started");
 
     /*Create the ancestor basic object*/
-    lv_obj_t * cb = lv_label_create(par, copy);
+    lv_obj_t * cb = lv_obj_create(par, copy);
     LV_ASSERT_MEM(cb);
     if(cb == NULL) return NULL;
 
@@ -75,11 +76,12 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new checkbox object*/
     if(copy == NULL) {
-        lv_label_set_text_static(cb, "Check box");
+        ext->txt = "Check box";
+        ext->static_txt = 1;
         lv_theme_apply(cb, LV_THEME_CHECKBOX);
         lv_obj_add_flag(cb, LV_OBJ_FLAG_CLICKABLE);
         lv_obj_add_flag(cb, LV_OBJ_FLAG_CHECKABLE);
-
+        lv_obj_set_size(cb, LV_SIZE_AUTO, LV_SIZE_AUTO);
     }
     else {
 
@@ -99,10 +101,87 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy)
  * Setter functions
  *====================*/
 
+/**
+ * Set the text of a check box. `txt` will be copied and may be deallocated
+ * after this function returns.
+ * @param cb pointer to a check box
+ * @param txt the text of the check box. NULL to refresh with the current text.
+ */
+void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
+{
+    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+    size_t len = strlen(txt);
+
+    if(!ext->static_txt) ext->txt = lv_mem_realloc(ext->txt, len + 1);
+    else  ext->txt = lv_mem_alloc(len + 1);
+
+    strcpy(ext->txt, txt);
+    ext->static_txt = 0;
+
+    if(cb->w_set == LV_SIZE_AUTO || cb->h_set == LV_SIZE_AUTO) {
+        lv_obj_set_size(cb, cb->w_set, cb->h_set);
+    }
+}
+
+/**
+ * Set the text of a check box. `txt` must not be deallocated during the life
+ * of this checkbox.
+ * @param cb pointer to a check box
+ * @param txt the text of the check box. NULL to refresh with the current text.
+ */
+void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
+{
+    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+
+    if(!ext->static_txt) lv_mem_free(ext->txt);
+
+    ext->txt = txt;
+    ext->static_txt = 1;
+
+    if(cb->w_set == LV_SIZE_AUTO || cb->h_set == LV_SIZE_AUTO) {
+        lv_obj_set_size(cb, cb->w_set, cb->h_set);
+    }
+}
+
+/**
+ * Set the state of the check box
+ * @param cb pointer to a check box object
+ * @param checked true: make the check box checked; false: make it unchecked
+ */
+void lv_checkbox_set_checked(lv_obj_t * cb, bool checked)
+{
+    if(checked) lv_obj_set_state(cb, LV_STATE_CHECKED);
+    else lv_obj_clear_state(cb, LV_STATE_CHECKED);
+    _lv_obj_remove_style_trans(cb);
+}
+
+/**
+ * Make the check box inactive (disabled)
+ * @param cb pointer to a check box object
+ * @param dis true; make the checkbox disabled; false: make the chackbox active
+ */
+void lv_checkbox_set_disabled(lv_obj_t * cb, bool dis)
+{
+    if(dis) lv_obj_set_state(cb, LV_STATE_DISABLED);
+    else lv_obj_clear_state(cb, LV_STATE_DISABLED);
+    _lv_obj_remove_style_trans(cb);
+}
+
 /*=====================
  * Getter functions
  *====================*/
 
+/**
+ * Get the text of a check box
+ * @param cb pointer to check box object
+ * @return pointer to the text of the check box
+ */
+const char * lv_checkbox_get_text(const lv_obj_t * cb)
+{
+    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+    return ext->txt;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -129,12 +208,14 @@ static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_
         lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
 
         const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
-        lv_coord_t line_height = lv_font_get_line_height(font);
+        lv_coord_t font_h = lv_font_get_line_height(font);
 
         lv_coord_t bg_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t bg_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_MAIN);
 
         lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
         lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
 
         lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
         lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
@@ -145,12 +226,32 @@ static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_
         lv_draw_rect_dsc_init(&bullet_dsc);
         lv_obj_init_draw_rect_dsc(cb, LV_CHECKBOX_PART_BULLET, &bullet_dsc);
         lv_area_t bullet_area;
-        bullet_area.x1 = cb->coords.x1 + bullet_leftm;
-        bullet_area.x2 = bullet_area.x1 + line_height + bullet_leftp + bullet_rightp - 1;
-        bullet_area.y1 = cb->coords.y1 + bg_topp - bullet_topp + bullet_topm;
-        bullet_area.y2 = bullet_area.y1 + line_height + bullet_topp + bullet_bottomp - 1;
+        bullet_area.x1 = cb->coords.x1 + bg_leftp + bullet_leftm;
+        bullet_area.x2 = bullet_area.x1 + font_h + bullet_leftp + bullet_rightp - 1;
+        bullet_area.y1 = cb->coords.y1 + bg_topp + bullet_topm;
+        bullet_area.y2 = bullet_area.y1 + font_h + bullet_topp + bullet_bottomp - 1;
 
         lv_draw_rect(&bullet_area, clip_area, &bullet_dsc);
+
+        lv_coord_t line_space = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t letter_space = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
+
+        lv_point_t txt_size;
+        _lv_txt_get_size(&txt_size, ext->txt, font, letter_space, line_space, LV_COORD_MAX, LV_TXT_FLAG_NONE);
+
+        lv_draw_label_dsc_t txt_dsc;
+        lv_draw_label_dsc_init(&txt_dsc);
+        lv_obj_init_draw_label_dsc(cb, LV_CHECKBOX_PART_MAIN, &txt_dsc);
+
+        lv_coord_t y_ofs = (lv_area_get_height(&bullet_area) - font_h) / 2;
+        lv_area_t txt_area;
+        txt_area.x1 = bullet_area.x2 + bullet_rightm;
+        txt_area.x2 = txt_area.x1 + txt_size.x;
+        txt_area.y1 = cb->coords.y1 + bg_topp + y_ofs;
+        txt_area.y2 = txt_area.y1 + txt_size.y;
+
+        lv_draw_label(&txt_area, clip_area, &txt_dsc, ext->txt, NULL);
+
     } else {
         ancestor_design(cb, clip_area, mode);
     }
@@ -166,8 +267,6 @@ static lv_design_res_t lv_checkbox_design(lv_obj_t * cb, const lv_area_t * clip_
  */
 static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
 {
-    lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
-
     lv_res_t res;
     /* Include the ancient signal function */
     res = ancestor_signal(cb, sign, param);
@@ -182,6 +281,34 @@ static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param
     else if (sign == LV_SIGNAL_GET_TYPE) {
         return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
     }
+    else if (sign == LV_SIGNAL_GET_SELF_SIZE) {
+        lv_point_t * p = param;
+        lv_checkbox_ext_t * ext = lv_obj_get_ext_attr(cb);
+
+        const lv_font_t * font = lv_obj_get_style_text_font(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t font_h = lv_font_get_line_height(font);
+        lv_coord_t line_space = lv_obj_get_style_text_line_space(cb, LV_CHECKBOX_PART_MAIN);
+        lv_coord_t letter_space = lv_obj_get_style_text_letter_space(cb, LV_CHECKBOX_PART_MAIN);
+
+        lv_point_t txt_size;
+        _lv_txt_get_size(&txt_size, ext->txt, font, letter_space, line_space, LV_COORD_MAX, LV_TXT_FLAG_NONE);
+
+        lv_coord_t bullet_leftm = lv_obj_get_style_margin_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topm = lv_obj_get_style_margin_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightm = lv_obj_get_style_margin_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomm = lv_obj_get_style_margin_bottom(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_leftp = lv_obj_get_style_pad_left(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_rightp = lv_obj_get_style_pad_right(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_topp = lv_obj_get_style_pad_top(cb, LV_CHECKBOX_PART_BULLET);
+        lv_coord_t bullet_bottomp = lv_obj_get_style_pad_bottom(cb, LV_CHECKBOX_PART_BULLET);
+        lv_point_t bullet_size;
+        bullet_size.x = font_h + bullet_leftm + bullet_rightm + bullet_leftp + bullet_rightp;
+        bullet_size.y = font_h + bullet_topm + bullet_bottomm + bullet_topp + bullet_bottomp;
+
+        p->x = bullet_size.x + txt_size.x;
+        p->y = LV_MATH_MAX(bullet_size.y, txt_size.y);
+
+    }
 
     return res;
 }
diff --git a/src/lv_widgets/lv_checkbox.h b/src/lv_widgets/lv_checkbox.h
index 43753b845..a635dbf0d 100644
--- a/src/lv_widgets/lv_checkbox.h
+++ b/src/lv_widgets/lv_checkbox.h
@@ -14,20 +14,15 @@ extern "C" {
  *      INCLUDES
  *********************/
 #include "../lv_conf_internal.h"
+#include "../lv_core/lv_obj.h"
 
 #if LV_USE_CHECKBOX != 0
 
 /*Testing of dependencies*/
-#if LV_USE_BTN == 0
-#error "lv_cb: lv_btn is required. Enable it in lv_conf.h (LV_USE_BTN  1) "
-#endif
-
 #if LV_USE_LABEL == 0
 #error "lv_cb: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
 #endif
 
-#include "lv_label.h"
-
 /*********************
  *      DEFINES
  *********************/
@@ -38,10 +33,10 @@ extern "C" {
 
 /*Data of check box*/
 typedef struct {
-    lv_label_ext_t label_ext;
-
     /*New data for this widget */
     lv_style_list_t style_bullet;
+    char * txt;
+    uint32_t static_txt :1;
 } lv_checkbox_ext_t;
 
 /** Checkbox styles. */
@@ -68,65 +63,24 @@ lv_obj_t * lv_checkbox_create(lv_obj_t * par, const lv_obj_t * copy);
  * Setter functions
  *====================*/
 
-
-/**
- * Set the text of a check box. `txt` will be copied and may be deallocated
- * after this function returns.
- * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
- */
-static inline void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
-{
-    lv_label_set_text(cb, txt);
-}
-
-/**
- * Set the text of a check box. `txt` must not be deallocated during the life
- * of this checkbox.
- * @param cb pointer to a check box
- * @param txt the text of the check box. NULL to refresh with the current text.
- */
-static inline void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
-{
-    lv_label_set_text_static(cb, txt);
-}
-
 /**
  * Set the state of the check box
  * @param cb pointer to a check box object
  * @param checked true: make the check box checked; false: make it unchecked
  */
-static inline void lv_checkbox_set_checked(lv_obj_t * cb, bool checked)
-{
-    if(checked) lv_obj_set_state(cb, LV_STATE_CHECKED);
-    else lv_obj_clear_state(cb, LV_STATE_CHECKED);
-}
+void lv_checkbox_set_checked(lv_obj_t * cb, bool checked);
 
 /**
  * Make the check box inactive (disabled)
  * @param cb pointer to a check box object
- * @param dis true; make the checkbox disabled; false: make the chackbox active
+ * @param dis true; make the checkbox disabled; false: make the checkbox active
  */
-static inline void lv_checkbox_set_disabled(lv_obj_t * cb, bool dis)
-{
-    if(dis) lv_obj_set_state(cb, LV_STATE_DISABLED);
-    else lv_obj_clear_state(cb, LV_STATE_DISABLED);
-}
+void lv_checkbox_set_disabled(lv_obj_t * cb, bool dis);
 
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the text of a check box
- * @param cb pointer to check box object
- * @return pointer to the text of the check box
- */
-static inline const char * lv_checkbox_get_text(const lv_obj_t * cb)
-{
-    return lv_label_get_text(cb);
-}
-
 /**
  * Get the current state of the check box
  * @param cb pointer to a check box object

From 06281e38cf5d947e20081d3bf913247669a25f6e Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 29 Sep 2020 14:27:15 +0200
Subject: [PATCH 44/84] img: use self_size and LV_SIZE_AUTO to automatically
 set size to image size

---
 src/lv_widgets/lv_img.c | 61 ++++++++++-------------------------------
 src/lv_widgets/lv_img.h | 16 -----------
 2 files changed, 14 insertions(+), 63 deletions(-)

diff --git a/src/lv_widgets/lv_img.c b/src/lv_widgets/lv_img.c
index 27a80e54a..7cb3abf49 100644
--- a/src/lv_widgets/lv_img.c
+++ b/src/lv_widgets/lv_img.c
@@ -84,7 +84,6 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->angle = 0;
     ext->zoom = LV_IMG_ZOOM_NONE;
     ext->antialias = LV_ANTIALIAS ? 1 : 0;
-    ext->auto_size = 1;
     ext->offset.x  = 0;
     ext->offset.y  = 0;
     ext->pivot.x = 0;
@@ -102,23 +101,15 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy)
         /* Enable auto size for non screens
          * because image screens are wallpapers
          * and must be screen sized*/
-        if(par != NULL) {
-            ext->auto_size = 1;
-        }
-        else {
-            ext->auto_size = 0;
-        }
+        if(par) lv_obj_set_size(img, LV_SIZE_AUTO, LV_SIZE_AUTO);
     }
     else {
         lv_img_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->auto_size     = copy_ext->auto_size;
-        ext->zoom          = copy_ext->zoom;
-        ext->angle         = copy_ext->angle;
-        ext->antialias     = copy_ext->antialias;
-        ext->offset.x     = copy_ext->offset.x;
-        ext->offset.y     = copy_ext->offset.y;
-        ext->pivot.x     = copy_ext->pivot.x;
-        ext->pivot.y     = copy_ext->pivot.y;
+        ext->zoom      = copy_ext->zoom;
+        ext->angle     = copy_ext->angle;
+        ext->antialias = copy_ext->antialias;
+        ext->offset  = copy_ext->offset;
+        ext->pivot   = copy_ext->pivot;
         lv_img_set_src(img, copy_ext->src);
 
         /*Refresh the style with new signal function*/
@@ -143,6 +134,8 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img)
 {
     LV_ASSERT_OBJ(img, LV_OBJX_NAME);
 
+    lv_obj_invalidate(img);
+
     lv_img_src_t src_type = lv_img_src_get_type(src_img);
     lv_img_ext_t * ext    = lv_obj_get_ext_attr(img);
 
@@ -225,9 +218,7 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img)
     ext->pivot.x = header.w / 2;
     ext->pivot.y = header.h / 2;
 
-    if(lv_img_get_auto_size(img) != false) {
-        lv_obj_set_size(img, ext->w, ext->h);
-    }
+    _lv_obj_handle_self_size_chg(img);
 
     /*Provide enough room for the rotated corners*/
     if(ext->angle || ext->zoom != LV_IMG_ZOOM_NONE) _lv_obj_refresh_ext_draw_pad(img);
@@ -235,21 +226,6 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img)
     lv_obj_invalidate(img);
 }
 
-/**
- * Enable the auto size feature.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: auto size enable, false: auto size disable
- */
-void lv_img_set_auto_size(lv_obj_t * img, bool en)
-{
-    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
-
-    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
-
-    ext->auto_size = (en == false ? 0 : 1);
-}
-
 /**
  * Set an offset for the source of an image.
  * so the image will be displayed from the new origin.
@@ -440,20 +416,6 @@ const void * lv_img_get_src(lv_obj_t * img)
     return ext->src;
 }
 
-/**
- * Get the auto size enable attribute
- * @param img pointer to an image
- * @return true: auto size is enabled, false: auto size is disabled
- */
-bool lv_img_get_auto_size(const lv_obj_t * img)
-{
-    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
-
-    lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
-
-    return ext->auto_size == 0 ? false : true;
-}
-
 /**
  * Get the offset.x attribute of the img object.
  * @param img pointer to an image
@@ -849,6 +811,11 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
         else
             info->result = _lv_obj_is_click_point_on(img, info->point);
     }
+    else if(sign == LV_SIGNAL_GET_SELF_SIZE) {
+        lv_point_t * p = param;
+        p->x = ext->w;
+        p->y = ext->h;
+    }
 
     return res;
 }
diff --git a/src/lv_widgets/lv_img.h b/src/lv_widgets/lv_img.h
index d73dbad61..39b82e3cd 100644
--- a/src/lv_widgets/lv_img.h
+++ b/src/lv_widgets/lv_img.h
@@ -41,7 +41,6 @@ typedef struct {
     lv_point_t pivot;     /*rotation center of the image*/
     uint16_t zoom;         /*256 means no zoom, 512 double size, 128 half size*/
     uint8_t src_type : 2;  /*See: lv_img_src_t*/
-    uint8_t auto_size : 1; /*1: automatically set the object size to the image size*/
     uint8_t cf : 5;        /*Color format from `lv_img_color_format_t`*/
     uint8_t antialias : 1; /*Apply anti-aliasing in transformations (rotate, zoom)*/
 } lv_img_ext_t;
@@ -75,14 +74,6 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy);
  */
 void lv_img_set_src(lv_obj_t * img, const void * src_img);
 
-/**
- * Enable the auto size feature.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: auto size enable, false: auto size disable
- */
-void lv_img_set_auto_size(lv_obj_t * img, bool autosize_en);
-
 /**
  * Set an offset for the source of an image.
  * so the image will be displayed from the new origin.
@@ -146,13 +137,6 @@ void lv_img_set_antialias(lv_obj_t * img, bool antialias);
  */
 const void * lv_img_get_src(lv_obj_t * img);
 
-/**
- * Get the auto size enable attribute
- * @param img pointer to an image
- * @return true: auto size is enabled, false: auto size is disabled
- */
-bool lv_img_get_auto_size(const lv_obj_t * img);
-
 /**
  * Get the offset.x attribute of the img object.
  * @param img pointer to an image

From afc5475196891366af59ad2efe353d3c37558fc8 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 30 Sep 2020 06:12:29 +0200
Subject: [PATCH 45/84] rework table and textarea

---
 src/lv_core/lv_grid.c             |   6 -
 src/lv_core/lv_grid.h             |   1 -
 src/lv_themes/lv_theme.c          |   3 +-
 src/lv_themes/lv_theme_material.c |   9 +-
 src/lv_themes/lv_theme_mono.c     |   9 +-
 src/lv_themes/lv_theme_template.c |   9 +-
 src/lv_widgets/lv_btn.c           |   1 -
 src/lv_widgets/lv_imgbtn.c        |  52 ++--
 src/lv_widgets/lv_imgbtn.h        |  84 ++-----
 src/lv_widgets/lv_table.c         | 211 +++++++----------
 src/lv_widgets/lv_table.h         |   5 +-
 src/lv_widgets/lv_textarea.c      | 380 ++++++++++--------------------
 src/lv_widgets/lv_textarea.h      |  76 +-----
 13 files changed, 286 insertions(+), 560 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index cd0170d1a..df8754834 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -37,12 +37,6 @@ static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 /**********************
  *  STATIC VARIABLES
  **********************/
-static const lv_coord_t lv_grid_1_dsc[1] = {LV_GRID_FR(1)};
-const lv_grid_t lv_grid_center = {
-        .col_dsc = lv_grid_1_dsc,
-        .col_dsc_len = 1,
-        .col_place = LV_GRID_CENTER,
-        .row_place = LV_GRID_CENTER};
 
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 4c524ffe5..331ea4302 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -166,7 +166,6 @@ void lv_grid_item_refr_pos(lv_obj_t * item);
 /**********************
  * GLOBAL VARIABLES
  **********************/
-extern const lv_grid_t lv_grid_center;
 
 /**********************
  *      MACROS
diff --git a/src/lv_themes/lv_theme.c b/src/lv_themes/lv_theme.c
index 70bac97dc..e3a2b7512 100644
--- a/src/lv_themes/lv_theme.c
+++ b/src/lv_themes/lv_theme.c
@@ -424,10 +424,9 @@ static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_BG);
+            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_MAIN);
             _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_CURSOR);
-            _lv_obj_reset_style_list_no_refr(obj, LV_TEXTAREA_PART_SCROLLBAR);
             break;
 #endif
 
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 1dd0b110c..49c4934c5 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -1261,7 +1261,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
         {
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
             int idx = 1; /* start value should be 1, not zero, since cell styles 
@@ -1269,7 +1269,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
                             in the enum (lv_table.h) */ 
                          /* declaring idx outside loop to work with older compilers */
 	    for (;idx <= LV_TABLE_CELL_STYLE_CNT; idx ++ ) {
-              list = lv_obj_get_style_list(obj, idx);
+              list = _lv_obj_get_style_list(obj, idx);
              _lv_style_list_add_style(list, &styles->table_cell);
             }
             break;
@@ -1299,7 +1299,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
@@ -1308,9 +1308,6 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
-
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->sb);
             break;
 
 #endif
diff --git a/src/lv_themes/lv_theme_mono.c b/src/lv_themes/lv_theme_mono.c
index bc12cad59..bbf828feb 100644
--- a/src/lv_themes/lv_theme_mono.c
+++ b/src/lv_themes/lv_theme_mono.c
@@ -865,7 +865,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
         {
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
             int idx = 1; /* start value should be 1, not zero, since cell styles
@@ -873,7 +873,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
                             in the enum (lv_table.h) */
                          /* declaring idx outside loop to work with older compilers */
             for (; idx <= LV_TABLE_CELL_STYLE_CNT; idx ++ ) {
-              list = lv_obj_get_style_list(obj, idx);
+              list = _lv_obj_get_style_list(obj, idx);
               _lv_style_list_add_style(list, &styles->bg);
               _lv_style_list_add_style(list, &styles->no_radius);
             }
@@ -905,14 +905,11 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
-
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->sb);
             break;
 #endif
 
diff --git a/src/lv_themes/lv_theme_template.c b/src/lv_themes/lv_theme_template.c
index 39a15dcf8..9040c99e3 100644
--- a/src/lv_themes/lv_theme_template.c
+++ b/src/lv_themes/lv_theme_template.c
@@ -718,7 +718,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
         {
-            list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
             int idx = 1; /* start value should be 1, not zero, since cell styles
@@ -726,7 +726,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
                             in the enum (lv_table.h) */
                          /* declaring idx outside loop to work with older compilers */
             for (; idx <= LV_TABLE_CELL_STYLE_CNT; idx ++ ) {
-              list = lv_obj_get_style_list(obj, idx);
+              list = _lv_obj_get_style_list(obj, idx);
               _lv_style_list_add_style(list, &styles->bg);
             }
             break;
@@ -757,7 +757,7 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
+            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
@@ -766,9 +766,6 @@ void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
-
-            list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
-            _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 
diff --git a/src/lv_widgets/lv_btn.c b/src/lv_widgets/lv_btn.c
index 376999675..b30744c3d 100644
--- a/src/lv_widgets/lv_btn.c
+++ b/src/lv_widgets/lv_btn.c
@@ -71,7 +71,6 @@ lv_obj_t * lv_btn_create(lv_obj_t * parent, const lv_obj_t * copy)
         /*Set layout if the button is not a screen*/
         if(parent) {
             lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
-            lv_obj_set_grid(btn, &lv_grid_center);
         }
 
         lv_theme_apply(btn, LV_THEME_BTN);
diff --git a/src/lv_widgets/lv_imgbtn.c b/src/lv_widgets/lv_imgbtn.c
index 6caa98f19..a84a04935 100644
--- a/src/lv_widgets/lv_imgbtn.c
+++ b/src/lv_widgets/lv_imgbtn.c
@@ -30,6 +30,7 @@
 static lv_design_res_t lv_imgbtn_design(lv_obj_t * imgbtn, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * param);
 static void refr_img(lv_obj_t * imgbtn);
+lv_imgbtn_state_t get_state(const lv_obj_t * imgbtn);
 
 /**********************
  *  STATIC VARIABLES
@@ -100,7 +101,7 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * par, const lv_obj_t * copy)
 #endif
         ext->tiled = copy_ext->tiled;
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(imgbtn, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(imgbtn, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("image button created");
@@ -115,10 +116,10 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * par, const lv_obj_t * copy)
 /**
  * Set images for a state of the image button
  * @param imgbtn pointer to an image button object
- * @param state for which state set the new image (from `lv_btn_state_t`) `
+ * @param state for which state set the new image
  * @param src pointer to an image source (a C array or path to a file)
  */
-void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src)
+void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
 
@@ -137,7 +138,7 @@ void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src
 /**
  * Set images for a state of the image button
  * @param imgbtn pointer to an image button object
- * @param state for which state set the new image (from `lv_btn_state_t`) `
+ * @param state for which state set the new image
  * @param src_left pointer to an image source for the left side of the button (a C array or path to
  * a file)
  * @param src_mid pointer to an image source for the middle of the button (ideally 1px wide) (a C
@@ -145,7 +146,7 @@ void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src
  * @param src_right pointer to an image source for the right side of the button (a C array or path
  * to a file)
  */
-void lv_imgbtn_set_src_tiled(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src_left, const void * src_mid,
+void lv_imgbtn_set_src_tiled(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src_left, const void * src_mid,
                              const void * src_right)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
@@ -180,7 +181,7 @@ void lv_imgbtn_set_src_tiled(lv_obj_t * imgbtn, lv_btn_state_t state, const void
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to an image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state)
+const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
 
@@ -196,7 +197,7 @@ const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state)
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the left image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state)
+const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_imgbtn_state_t state)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
 
@@ -211,7 +212,7 @@ const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state)
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the middle image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state)
+const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_imgbtn_state_t state)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
 
@@ -226,7 +227,7 @@ const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state)
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the left image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_btn_state_t state)
+const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_imgbtn_state_t state)
 {
     LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
 
@@ -307,7 +308,7 @@ static lv_design_res_t lv_imgbtn_design(lv_obj_t * imgbtn, const lv_area_t * cli
 
         /*Just draw an image*/
         lv_imgbtn_ext_t * ext    = lv_obj_get_ext_attr(imgbtn);
-        lv_btn_state_t state     = lv_imgbtn_get_state(imgbtn);
+        lv_imgbtn_state_t state  = get_state(imgbtn);
 
         /*Simply draw the middle src if no tiled*/
         if(!ext->tiled) {
@@ -449,9 +450,10 @@ static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(imgbtn, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_STYLE_CHG) {
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_STYLE_CHG) {
         /* If the style changed then the button was clicked, released etc. so probably the state was
          * changed as well Set the new image for the new state.*/
         refr_img(imgbtn);
@@ -478,7 +480,7 @@ static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * par
 static void refr_img(lv_obj_t * imgbtn)
 {
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
-    lv_btn_state_t state  = lv_imgbtn_get_state(imgbtn);
+    lv_imgbtn_state_t state  = get_state(imgbtn);
     lv_img_header_t header;
 
     const void * src = ext->img_src_mid[state];
@@ -508,4 +510,26 @@ static void refr_img(lv_obj_t * imgbtn)
     lv_obj_invalidate(imgbtn);
 }
 
+lv_imgbtn_state_t get_state(const lv_obj_t * imgbtn)
+{
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
+    lv_state_t obj_state = lv_obj_get_state(imgbtn);
+
+    if(obj_state & LV_STATE_DISABLED) {
+        if(obj_state & LV_STATE_CHECKED) return LV_IMGBTN_STATE_CHECKED_DISABLED;
+        else return LV_IMGBTN_STATE_DISABLED;
+    }
+
+    if(obj_state & LV_STATE_CHECKED) {
+        if(obj_state & LV_STATE_PRESSED) return LV_IMGBTN_STATE_CHECKED_PRESSED;
+        else return LV_IMGBTN_STATE_CHECKED_RELEASED;
+    }
+    else {
+        if(obj_state & LV_STATE_PRESSED) return LV_IMGBTN_STATE_PRESSED;
+        else return LV_IMGBTN_STATE_RELEASED;
+    }
+}
+
+
 #endif
diff --git a/src/lv_widgets/lv_imgbtn.h b/src/lv_widgets/lv_imgbtn.h
index 5f7d35a62..59019e316 100644
--- a/src/lv_widgets/lv_imgbtn.h
+++ b/src/lv_widgets/lv_imgbtn.h
@@ -17,11 +17,6 @@ extern "C" {
 
 #if LV_USE_IMGBTN != 0
 
-/*Testing of dependencies*/
-#if LV_USE_BTN == 0
-#error "lv_imgbtn: lv_btn is required. Enable it in lv_conf.h (LV_USE_BTN  1) "
-#endif
-
 #include "../lv_core/lv_obj.h"
 #include "lv_btn.h"
 #include "../lv_draw/lv_draw_img.h"
@@ -29,18 +24,26 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
+typedef enum {
+    LV_IMGBTN_STATE_RELEASED,
+    LV_IMGBTN_STATE_PRESSED,
+    LV_IMGBTN_STATE_DISABLED,
+    LV_IMGBTN_STATE_CHECKED_RELEASED,
+    LV_IMGBTN_STATE_CHECKED_PRESSED,
+    LV_IMGBTN_STATE_CHECKED_DISABLED,
+    _LV_IMGBTN_STATE_NUM,
+}lv_imgbtn_state_t;
 
 /**********************
  *      TYPEDEFS
  **********************/
 /*Data of image button*/
 typedef struct {
-    lv_btn_ext_t btn; /*Ext. of ancestor*/
     /*New data for this type */
-    const void * img_src_mid[_LV_BTN_STATE_LAST];   /*Store center images to each state*/
+    const void * img_src_mid[_LV_IMGBTN_STATE_NUM];   /*Store center images to each state*/
 #if LV_IMGBTN_TILED
-    const void * img_src_left[_LV_BTN_STATE_LAST];  /*Store left side images to each state*/
-    const void * img_src_right[_LV_BTN_STATE_LAST]; /*Store right side images to each state*/
+    const void * img_src_left[_LV_IMGBTN_STATE_NUM];  /*Store left side images to each state*/
+    const void * img_src_right[_LV_IMGBTN_STATE_NUM]; /*Store right side images to each state*/
 #endif
     lv_img_cf_t act_cf; /*Color format of the currently active image*/
     uint8_t tiled   : 1; /*1: the middle src will be repeated to fill the user defined width*/
@@ -76,16 +79,16 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * par, const lv_obj_t * copy);
 /**
  * Set images for a state of the image button
  * @param imgbtn pointer to an image button object
- * @param state for which state set the new image (from `lv_btn_state_t`) `
+ * @param state for which state set the new image
  * @param src pointer to an image source (a C array or path to a file)
  */
-void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src);
+void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src);
 
 #if LV_IMGBTN_TILED
 /**
  * Set images for a state of the image button
  * @param imgbtn pointer to an image button object
- * @param state for which state set the new image (from `lv_btn_state_t`) `
+ * @param state for which state set the new image
  * @param src_left pointer to an image source for the left side of the button (a C array or path to
  * a file)
  * @param src_mid pointer to an image source for the middle of the button (ideally 1px wide) (a C
@@ -93,40 +96,11 @@ void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src
  * @param src_right pointer to an image source for the right side of the button (a C array or path
  * to a file)
  */
-void lv_imgbtn_set_src_tiled(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src_left, const void * src_mid,
+void lv_imgbtn_set_src_tiled(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src_left, const void * src_mid,
                              const void * src_right);
 
 #endif
 
-/**
- * Enable the toggled states. On release the button will change from/to toggled state.
- * @param imgbtn pointer to an image button object
- * @param tgl true: enable toggled states, false: disable
- */
-static inline void lv_imgbtn_set_checkable(lv_obj_t * imgbtn, bool tgl)
-{
-    lv_btn_set_checkable(imgbtn, tgl);
-}
-
-/**
- * Set the state of the image button
- * @param imgbtn pointer to an image button object
- * @param state the new state of the button (from lv_btn_state_t enum)
- */
-static inline void lv_imgbtn_set_state(lv_obj_t * imgbtn, lv_btn_state_t state)
-{
-    lv_btn_set_state(imgbtn, state);
-}
-
-/**
- * Toggle the state of the image button (ON->OFF, OFF->ON)
- * @param imgbtn pointer to a image button object
- */
-static inline void lv_imgbtn_toggle(lv_obj_t * imgbtn)
-{
-    lv_btn_toggle(imgbtn);
-}
-
 /*=====================
  * Getter functions
  *====================*/
@@ -138,7 +112,7 @@ static inline void lv_imgbtn_toggle(lv_obj_t * imgbtn)
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to an image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state);
+const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
 
 #else
 
@@ -148,7 +122,7 @@ const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state);
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the left image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state);
+const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
 
 /**
  * Get the middle image in a given state
@@ -156,7 +130,7 @@ const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state);
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the middle image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state);
+const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
 
 /**
  * Get the right image in a given state
@@ -164,28 +138,10 @@ const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state);
  * @param state the state where to get the image (from `lv_btn_state_t`) `
  * @return pointer to the left image source (a C array or path to a file)
  */
-const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_btn_state_t state);
+const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
 
 #endif
-/**
- * Get the current state of the image button
- * @param imgbtn pointer to a image button object
- * @return the state of the button (from lv_btn_state_t enum)
- */
-static inline lv_btn_state_t lv_imgbtn_get_state(const lv_obj_t * imgbtn)
-{
-    return lv_btn_get_state(imgbtn);
-}
 
-/**
- * Get the toggle enable attribute of the image button
- * @param imgbtn pointer to a image button object
- * @return true: toggle enabled, false: disabled
- */
-static inline bool lv_imgbtn_get_checkable(const lv_obj_t * imgbtn)
-{
-    return lv_btn_get_checkable(imgbtn);
-}
 
 /*=====================
  * Other functions
diff --git a/src/lv_widgets/lv_table.c b/src/lv_widgets/lv_table.c
index 501af6a24..c79a64999 100644
--- a/src/lv_widgets/lv_table.c
+++ b/src/lv_widgets/lv_table.c
@@ -81,6 +81,7 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->col_cnt       = 0;
     ext->row_cnt       = 0;
     ext->row_h         = NULL;
+    ext->col_w         = NULL;
     ext->cell_types    = 1;
 
     uint16_t i;
@@ -88,16 +89,22 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_style_list_init(&ext->cell_style[i]);
     }
 
-    for(i = 0; i < LV_TABLE_COL_MAX; i++) {
-        ext->col_w[i] = LV_DPI;
-    }
-
     /*The signal and design functions are not copied so set them here*/
     lv_obj_set_signal_cb(table, lv_table_signal);
     lv_obj_set_design_cb(table, lv_table_design);
 
     /*Init the new table table*/
     if(copy == NULL) {
+        ext->col_cnt = 1;
+        ext->row_cnt = 1;
+        ext->col_w = lv_mem_alloc(ext->col_cnt * sizeof(ext->col_w[0]));
+        ext->row_h = lv_mem_alloc(ext->row_cnt * sizeof(ext->row_h[0]));
+        ext->col_w[0] = LV_DPI;
+        ext->row_h[0] = LV_DPI; /*It will be overwritten when the theme is applied*/
+        ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
+
+        lv_obj_set_size(table, LV_SIZE_AUTO, 80);
+
         lv_theme_apply(table, LV_THEME_TABLE);
     }
     /*Copy an existing table*/
@@ -110,7 +117,7 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_table_set_col_cnt(table, copy_ext->col_cnt);
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(table, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(table, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("table created");
@@ -136,15 +143,10 @@ void lv_table_set_cell_value(lv_obj_t * table, uint16_t row, uint16_t col, const
     LV_ASSERT_NULL(txt);
 
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(col >= ext->col_cnt) {
-        LV_LOG_WARN("lv_table_set_cell_value: invalid column");
-        return;
-    }
 
     /*Auto expand*/
-    if(row >= ext->row_cnt) {
-        lv_table_set_row_cnt(table, row + 1);
-    }
+    if(col >= ext->col_cnt) lv_table_set_col_cnt(table, col + 1);
+    if(row >= ext->row_cnt) lv_table_set_row_cnt(table, row + 1);
 
     uint32_t cell = row * ext->col_cnt + col;
     lv_table_cell_format_t format;
@@ -192,31 +194,19 @@ void lv_table_set_row_cnt(lv_obj_t * table, uint16_t row_cnt)
     uint16_t old_row_cnt = ext->row_cnt;
     ext->row_cnt         = row_cnt;
 
-    if(ext->row_cnt > 0) {
-        ext->row_h = lv_mem_realloc(ext->row_h, ext->row_cnt * sizeof(ext->row_h[0]));
-        LV_ASSERT_MEM(ext->row_h);
-        if(ext->row_h == NULL) return;
-    }
-    else {
-        lv_mem_free(ext->row_h);
-        ext->row_h = NULL;
-    }
+    ext->row_h = lv_mem_realloc(ext->row_h, ext->row_cnt * sizeof(ext->row_h[0]));
+    LV_ASSERT_MEM(ext->row_h);
+    if(ext->row_h == NULL) return;
 
-    if(ext->row_cnt > 0 && ext->col_cnt > 0) {
-        ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
-        LV_ASSERT_MEM(ext->cell_data);
-        if(ext->cell_data == NULL) return;
+    ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
+    LV_ASSERT_MEM(ext->cell_data);
+    if(ext->cell_data == NULL) return;
 
-        /*Initialize the new fields*/
-        if(old_row_cnt < row_cnt) {
-            uint16_t old_cell_cnt = old_row_cnt * ext->col_cnt;
-            uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
-            _lv_memset_00(&ext->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
-        }
-    }
-    else {
-        lv_mem_free(ext->cell_data);
-        ext->cell_data = NULL;
+    /*Initialize the new fields*/
+    if(old_row_cnt < row_cnt) {
+        uint32_t old_cell_cnt = old_row_cnt * ext->col_cnt;
+        uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
+        _lv_memset_00(&ext->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
     }
 
     refr_size(table);
@@ -225,38 +215,35 @@ void lv_table_set_row_cnt(lv_obj_t * table, uint16_t row_cnt)
 /**
  * Set the number of columns
  * @param table table pointer to a Table object
- * @param col_cnt number of columns. Must be < LV_TABLE_COL_MAX
+ * @param col_cnt number of columns.
  */
 void lv_table_set_col_cnt(lv_obj_t * table, uint16_t col_cnt)
 {
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
-    if(col_cnt >= LV_TABLE_COL_MAX) {
-        LV_LOG_WARN("lv_table_set_col_cnt: too many columns. Must be < LV_TABLE_COL_MAX.");
-        return;
-    }
-
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     uint16_t old_col_cnt = ext->col_cnt;
     ext->col_cnt         = col_cnt;
+    ext->col_w = lv_mem_realloc(ext->col_w, col_cnt * sizeof(ext->row_h[0]));
+    LV_ASSERT_MEM(ext->col_w);
+    if(ext->col_w == NULL) return;
 
-    if(ext->row_cnt > 0 && ext->col_cnt > 0) {
-        ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
-        LV_ASSERT_MEM(ext->cell_data);
-        if(ext->cell_data == NULL) return;
+    ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
+    LV_ASSERT_MEM(ext->cell_data);
+    if(ext->cell_data == NULL) return;
 
-        /*Initialize the new fields*/
-        if(old_col_cnt < col_cnt) {
-            uint16_t old_cell_cnt = old_col_cnt * ext->row_cnt;
-            uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
-            _lv_memset_00(&ext->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
+    /*Initialize the new fields*/
+    if(old_col_cnt < col_cnt) {
+        uint32_t old_cell_cnt = old_col_cnt * ext->row_cnt;
+        uint32_t new_cell_cnt = ext->col_cnt * ext->row_cnt;
+        _lv_memset_00(&ext->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(ext->cell_data[0]));
+
+        uint32_t col;
+        for(col = old_cell_cnt; col < new_cell_cnt; col++) {
+            ext->col_w[col] = LV_DPI;
         }
+    }
 
-    }
-    else {
-        lv_mem_free(ext->cell_data);
-        ext->cell_data = NULL;
-    }
     refr_size(table);
 }
 
@@ -270,13 +257,12 @@ void lv_table_set_col_width(lv_obj_t * table, uint16_t col_id, lv_coord_t w)
 {
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
-    if(col_id >= LV_TABLE_COL_MAX) {
-        LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
-        return;
-    }
-
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    ext->col_w[col_id]   = w;
+
+    /*Auto expand*/
+    if(col_id >= ext->col_cnt) lv_table_set_col_cnt(table, col_id + 1);
+
+    ext->col_w[col_id] = w;
     refr_size(table);
 }
 
@@ -292,15 +278,11 @@ void lv_table_set_cell_align(lv_obj_t * table, uint16_t row, uint16_t col, lv_la
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(col >= ext->col_cnt) {
-        LV_LOG_WARN("lv_table_set_cell_align: invalid column");
-        return;
-    }
 
     /*Auto expand*/
-    if(row >= ext->row_cnt) {
-        lv_table_set_row_cnt(table, row + 1);
-    }
+    if(col >= ext->col_cnt) lv_table_set_col_cnt(table, col + 1);
+    if(row >= ext->row_cnt) lv_table_set_row_cnt(table, row + 1);
+
     uint32_t cell = row * ext->col_cnt + col;
 
     if(ext->cell_data[cell] == NULL) {
@@ -330,15 +312,10 @@ void lv_table_set_cell_type(lv_obj_t * table, uint16_t row, uint16_t col, uint8_
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(col >= ext->col_cnt) {
-        LV_LOG_WARN("lv_table_set_cell_type: invalid column");
-        return;
-    }
 
     /*Auto expand*/
-    if(row >= ext->row_cnt) {
-        lv_table_set_row_cnt(table, row + 1);
-    }
+    if(col >= ext->col_cnt) lv_table_set_col_cnt(table, col + 1);
+    if(row >= ext->row_cnt) lv_table_set_row_cnt(table, row + 1);
 
     uint32_t cell = row * ext->col_cnt + col;
 
@@ -374,15 +351,10 @@ void lv_table_set_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col, bool c
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(col >= ext->col_cnt) {
-        LV_LOG_WARN("lv_table_set_cell_crop: invalid column");
-        return;
-    }
 
     /*Auto expand*/
-    if(row >= ext->row_cnt) {
-        lv_table_set_row_cnt(table, row + 1);
-    }
+    if(col >= ext->col_cnt) lv_table_set_col_cnt(table, col + 1);
+    if(row >= ext->row_cnt) lv_table_set_row_cnt(table, row + 1);
 
     uint32_t cell = row * ext->col_cnt + col;
 
@@ -413,15 +385,10 @@ void lv_table_set_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col,
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(col >= ext->col_cnt) {
-        LV_LOG_WARN("lv_table_set_cell_merge_right: invalid column");
-        return;
-    }
 
     /*Auto expand*/
-    if(row >= ext->row_cnt) {
-        lv_table_set_row_cnt(table, row + 1);
-    }
+    if(col >= ext->col_cnt) lv_table_set_col_cnt(table, col + 1);
+    if(row >= ext->row_cnt) lv_table_set_row_cnt(table, row + 1);
 
     uint32_t cell = row * ext->col_cnt + col;
 
@@ -504,12 +471,13 @@ lv_coord_t lv_table_get_col_width(lv_obj_t * table, uint16_t col_id)
 {
     LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
-    if(col_id >= LV_TABLE_COL_MAX) {
+    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
+
+    if(col_id >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
         return 0;
     }
 
-    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     return ext->col_w[col_id];
 }
 
@@ -741,7 +709,7 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
         uint16_t row;
         uint16_t cell = 0;
 
-        cell_area.y2 = table->coords.y1 + bg_top - 1;
+        cell_area.y2 = table->coords.y1 + bg_top - 1 - lv_obj_get_scroll_top(table);
         for(row = 0; row < ext->row_cnt; row++) {
             lv_coord_t h_row = ext->row_h[row];
 
@@ -898,21 +866,24 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
 static lv_res_t lv_table_signal(lv_obj_t * table, lv_signal_t sign, void * param)
 {
     lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
+
+    /* Include the ancient signal function */
+    res = ancestor_signal(table, sign, param);
+    if(res != LV_RES_OK) return res;
+
+    lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
+
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
         info->result = lv_table_get_style(table, info->part);
         if(info->result != NULL) return LV_RES_OK;
         else return ancestor_signal(table, sign, param);
     }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(table, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
+    else if(sign == LV_SIGNAL_CLEANUP) {
         /*Free the cell texts*/
-        lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
         uint16_t i;
         for(i = 0; i < ext->col_cnt * ext->row_cnt; i++) {
             if(ext->cell_data[i]) {
@@ -925,12 +896,24 @@ static lv_res_t lv_table_signal(lv_obj_t * table, lv_signal_t sign, void * param
         if(ext->row_h) lv_mem_free(ext->row_h);
 
         for(i = 0; i < LV_TABLE_CELL_STYLE_CNT; i++) {
-            lv_obj_clean_style_list(table, LV_TABLE_PART_CELL1 + i);
+            _lv_obj_reset_style_list_no_refr(table, LV_TABLE_PART_CELL1 + i);
         }
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         refr_size(table);
     }
+    else if(sign == LV_SIGNAL_GET_SELF_SIZE) {
+        lv_point_t * p = param;
+        uint32_t i;
+        lv_coord_t w = 0;
+        for(i = 0; i < ext->col_cnt; i++) w += ext->col_w[i];
+
+        lv_coord_t h = 0;
+        for(i = 0; i < ext->row_cnt; i++) h += ext->row_h[i];
+
+        p->x = w;
+        p->y = h;
+    }
 
     return res;
 }
@@ -961,20 +944,9 @@ static lv_style_list_t * lv_table_get_style(lv_obj_t * table, uint8_t part)
 
 static void refr_size(lv_obj_t * table)
 {
-
-    lv_coord_t h = 0;
-    lv_coord_t w = 0;
-
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
-    if(ext->row_cnt == 0 || ext->col_cnt == 0) {
-        lv_obj_set_size(table, w, h);
-        return;
-    }
 
-    uint16_t i;
-    for(i = 0; i < ext->col_cnt; i++) {
-        w += ext->col_w[i];
-    }
+    uint32_t i;
 
     lv_style_int_t cell_left[LV_TABLE_CELL_STYLE_CNT];
     lv_style_int_t cell_right[LV_TABLE_CELL_STYLE_CNT];
@@ -999,18 +971,9 @@ static void refr_size(lv_obj_t * table)
     for(i = 0; i < ext->row_cnt; i++) {
         ext->row_h[i] = get_row_height(table, i, font, letter_space, line_space,
                                        cell_left, cell_right, cell_top, cell_bottom);
-        h += ext->row_h[i];
     }
 
-    lv_style_int_t bg_top = lv_obj_get_style_pad_top(table, LV_TABLE_PART_BG);
-    lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(table, LV_TABLE_PART_BG);
-    lv_style_int_t bg_left = lv_obj_get_style_pad_left(table, LV_TABLE_PART_BG);
-    lv_style_int_t bg_right = lv_obj_get_style_pad_right(table, LV_TABLE_PART_BG);
-    w += bg_left + bg_right;
-    h += bg_top + bg_bottom;
-
-    lv_obj_set_size(table, w + 1, h + 1);
-    lv_obj_invalidate(table); /*Always invalidate even if the size hasn't changed*/
+    _lv_obj_handle_self_size_chg(table);
 }
 
 static lv_coord_t get_row_height(lv_obj_t * table, uint16_t row_id, const lv_font_t ** font,
diff --git a/src/lv_widgets/lv_table.h b/src/lv_widgets/lv_table.h
index d05f2ce9a..f1c2131b7 100644
--- a/src/lv_widgets/lv_table.h
+++ b/src/lv_widgets/lv_table.h
@@ -41,8 +41,9 @@ extern "C" {
 #  define LV_TABLE_CELL_STYLE_CNT 4
 #endif
 #if (LV_TABLE_CELL_STYLE_CNT > 16)
-#  error LV_TABLE_CELL_STYLE_CNT cannot exceed 16
+#  error "LV_TABLE_CELL_STYLE_CNT cannot exceed 16"
 #endif
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -70,7 +71,7 @@ typedef struct {
     char ** cell_data;
     lv_coord_t * row_h;
     lv_style_list_t cell_style[LV_TABLE_CELL_STYLE_CNT];
-    lv_coord_t col_w[LV_TABLE_COL_MAX];
+    lv_coord_t * col_w;
     uint16_t cell_types : LV_TABLE_CELL_STYLE_CNT; /*Keep track which cell types exists to avoid dealing with unused ones*/
 } lv_table_ext_t;
 
diff --git a/src/lv_widgets/lv_textarea.c b/src/lv_widgets/lv_textarea.c
index 2b1489462..2a53d123e 100644
--- a/src/lv_widgets/lv_textarea.c
+++ b/src/lv_widgets/lv_textarea.c
@@ -13,6 +13,7 @@
 #include "../lv_misc/lv_debug.h"
 #include "../lv_core/lv_group.h"
 #include "../lv_core/lv_refr.h"
+#include "../lv_core/lv_indev.h"
 #include "../lv_draw/lv_draw.h"
 #include "../lv_themes/lv_theme.h"
 #include "../lv_misc/lv_anim.h"
@@ -46,10 +47,7 @@
  *  STATIC PROTOTYPES
  **********************/
 static lv_design_res_t lv_textarea_design(lv_obj_t * ta, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_design_res_t lv_textarea_scrollable_design(lv_obj_t * scrl, const lv_area_t * clip_area,
-                                                     lv_design_mode_t mode);
 static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param);
-static lv_res_t lv_textarea_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_textarea_get_style(lv_obj_t * ta, uint8_t part);
 #if LV_USE_ANIMATION
     static void cursor_blink_anim(lv_obj_t * ta, lv_anim_value_t show);
@@ -61,6 +59,8 @@ static bool char_is_accepted(lv_obj_t * ta, uint32_t c);
 static void refr_cursor_area(lv_obj_t * ta);
 static void update_cursor_position_on_click(lv_obj_t * ta, lv_signal_t sign, lv_indev_t * click_source);
 static lv_res_t insert_handler(lv_obj_t * ta, const char * txt);
+static void draw_placeholder(lv_obj_t * ta, const lv_area_t * clip_area);
+static void draw_cursor(lv_obj_t * ta, const lv_area_t * clip_area);
 
 /**********************
  *  STATIC VARIABLES
@@ -90,14 +90,12 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy)
     LV_LOG_TRACE("text area create started");
 
     /*Create the ancestor object*/
-    lv_obj_t * ta = lv_page_create(par, copy);
+    lv_obj_t * ta = lv_obj_create(par, copy);
     LV_ASSERT_MEM(ta);
     if(ta == NULL) return NULL;
 
     if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(ta);
     if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(ta);
-    if(scrl_signal == NULL) scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(ta));
-    if(scrl_design == NULL) scrl_design = lv_obj_get_design_cb(lv_page_get_scrollable(ta));
 
     /*Allocate the object type specific extended data*/
     lv_textarea_ext_t * ext = lv_obj_allocate_ext_attr(ta, sizeof(lv_textarea_ext_t));
@@ -134,30 +132,19 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy)
 #endif
 
     lv_obj_set_signal_cb(ta, lv_textarea_signal);
-    lv_obj_set_signal_cb(lv_page_get_scrollable(ta), lv_textarea_scrollable_signal);
     lv_obj_set_design_cb(ta, lv_textarea_design);
 
     /*Init the new text area object*/
     if(copy == NULL) {
-        lv_page_set_scrollable_fit2(ta, LV_FIT_PARENT, LV_FIT_TIGHT);
-
         ext->label = lv_label_create(ta, NULL);
-
-        lv_obj_set_design_cb(ext->page.scrl, lv_textarea_scrollable_design);
-
         lv_label_set_long_mode(ext->label, LV_LABEL_LONG_BREAK);
         lv_label_set_text(ext->label, "Text area");
-        lv_obj_set_click(ext->label, false);
         lv_obj_set_size(ta, LV_TEXTAREA_DEF_WIDTH, LV_TEXTAREA_DEF_HEIGHT);
-        lv_textarea_set_scrollbar_mode(ta, LV_SCROLLBAR_MODE_DRAG);
-
-        lv_obj_reset_style_list(ta, LV_PAGE_PART_SCROLLABLE);
         lv_theme_apply(ta, LV_THEME_TEXTAREA);
 
     }
     /*Copy an existing object*/
     else {
-        lv_obj_set_design_cb(ext->page.scrl, lv_textarea_scrollable_design);
         lv_textarea_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
         ext->label             = lv_label_create(ta, copy_ext->label);
         ext->pwd_mode          = copy_ext->pwd_mode;
@@ -188,7 +175,7 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy)
         if(copy_ext->one_line) lv_textarea_set_one_line(ta, true);
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(ta, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(ta, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
 #if LV_USE_ANIMATION
@@ -261,10 +248,6 @@ void lv_textarea_add_char(lv_obj_t * ta, uint32_t c)
     }
 
 
-    /*If a new line was added it shouldn't show edge flash effect*/
-    bool edge_flash_en = lv_textarea_get_edge_flash(ta);
-    lv_textarea_set_edge_flash(ta, false);
-
     if(ext->pwd_mode != 0) pwd_char_hider(ta); /*Make sure all the current text contains only '*'*/
 
     /*If the textarea is empty, invalidate it to hide the placeholder*/
@@ -313,9 +296,6 @@ void lv_textarea_add_char(lv_obj_t * ta, uint32_t c)
     /*Move the cursor after the new character*/
     lv_textarea_set_cursor_pos(ta, lv_textarea_get_cursor_pos(ta) + 1);
 
-    /*Revert the original edge flash state*/
-    lv_textarea_set_edge_flash(ta, edge_flash_en);
-
     lv_event_send(ta, LV_EVENT_VALUE_CHANGED, NULL);
 }
 
@@ -346,10 +326,6 @@ void lv_textarea_add_text(lv_obj_t * ta, const char * txt)
     lv_res_t res = insert_handler(ta, txt);
     if(res != LV_RES_OK) return;
 
-    /*If a new line was added it shouldn't show edge flash effect*/
-    bool edge_flash_en = lv_textarea_get_edge_flash(ta);
-    lv_textarea_set_edge_flash(ta, false);
-
     /*If the textarea is empty, invalidate it to hide the placeholder*/
     if(ext->placeholder_txt) {
         const char * txt_act = lv_label_get_text(ext->label);
@@ -395,9 +371,6 @@ void lv_textarea_add_text(lv_obj_t * ta, const char * txt)
     /*Move the cursor after the new text*/
     lv_textarea_set_cursor_pos(ta, lv_textarea_get_cursor_pos(ta) + _lv_txt_get_encoded_length(txt));
 
-    /*Revert the original edge flash state*/
-    lv_textarea_set_edge_flash(ta, edge_flash_en);
-
     lv_event_send(ta, LV_EVENT_VALUE_CHANGED, NULL);
 }
 
@@ -434,12 +407,6 @@ void lv_textarea_del_char(lv_obj_t * ta)
         if(txt[0] == '\0') lv_obj_invalidate(ta);
     }
 
-    /*Don't let 'width == 0' because cursor will not be visible*/
-    if(lv_obj_get_width(ext->label) == 0) {
-        lv_style_int_t border_width = lv_obj_get_style_border_width(ta, LV_TEXTAREA_PART_CURSOR);
-        lv_obj_set_width(ext->label, border_width == 0 ? 1 : border_width);
-    }
-
     if(ext->pwd_mode != 0) {
         uint32_t byte_pos = _lv_txt_encoded_get_byte_id(ext->pwd_tmp, ext->cursor.pos - 1);
         _lv_txt_cut(ext->pwd_tmp, ext->cursor.pos - 1, _lv_txt_encoded_size(&ext->pwd_tmp[byte_pos]));
@@ -513,12 +480,6 @@ void lv_textarea_set_text(lv_obj_t * ta, const char * txt)
         if(txt_act[0] == '\0') lv_obj_invalidate(ta);
     }
 
-    /*Don't let 'width == 0' because the cursor will not be visible*/
-    if(lv_obj_get_width(ext->label) == 0) {
-        lv_style_int_t border_width = lv_obj_get_style_border_width(ta, LV_TEXTAREA_PART_CURSOR);
-        lv_obj_set_width(ext->label, border_width == 0 ? 1 : border_width);
-    }
-
     if(ext->pwd_mode != 0) {
         ext->pwd_tmp = lv_mem_realloc(ext->pwd_tmp, strlen(txt) + 1);
         LV_ASSERT_MEM(ext->pwd_tmp);
@@ -619,9 +580,9 @@ void lv_textarea_set_cursor_pos(lv_obj_t * ta, int32_t pos)
     /*Position the label to make the cursor visible*/
     lv_obj_t * label_par = lv_obj_get_parent(ext->label);
     lv_point_t cur_pos;
-    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
-    lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_BG);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(ta, LV_TEXTAREA_PART_BG);
+    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
+    lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_MAIN);
+    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(ta, LV_TEXTAREA_PART_MAIN);
     lv_area_t label_cords;
     lv_area_t ta_cords;
     lv_label_get_letter_pos(ext->label, pos, &cur_pos);
@@ -630,25 +591,25 @@ void lv_textarea_set_cursor_pos(lv_obj_t * ta, int32_t pos)
 
     /*Check the top*/
     lv_coord_t font_h = lv_font_get_line_height(font);
-    if(lv_obj_get_y(label_par) + cur_pos.y < 0) {
-        lv_obj_set_y(label_par, -cur_pos.y + top);
+    if(cur_pos.y < lv_obj_get_scroll_top(ta)) {
+        lv_obj_scroll_to_y(label_par, cur_pos.y, LV_ANIM_ON);
     }
 
-    /*Check the bottom*/
-    if(label_cords.y1 + cur_pos.y + font_h + bottom > ta_cords.y2) {
-        lv_obj_set_y(label_par, -(cur_pos.y - lv_obj_get_height(ta) + font_h + top + bottom));
-    }
-    /*Check the left (use the font_h as general unit)*/
-    if(lv_obj_get_x(label_par) + cur_pos.x < font_h) {
-        lv_obj_set_x(label_par, -cur_pos.x + font_h);
-    }
-
-    lv_style_int_t right = lv_obj_get_style_pad_right(ta, LV_TEXTAREA_PART_BG);
-    lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_BG);
-    /*Check the right (use the font_h as general unit)*/
-    if(label_cords.x1 + cur_pos.x + font_h + right > ta_cords.x2) {
-        lv_obj_set_x(label_par, -(cur_pos.x - lv_obj_get_width(ta) + font_h + left + right));
-    }
+//    /*Check the bottom*/
+//    if(label_cords.y1 + cur_pos.y + font_h + bottom > ta_cords.y2) {
+//        lv_obj_set_y(label_par, -(cur_pos.y - lv_obj_get_height(ta) + font_h + top + bottom));
+//    }
+//    /*Check the left (use the font_h as general unit)*/
+//    if(lv_obj_get_x(label_par) + cur_pos.x < font_h) {
+//        lv_obj_set_x(label_par, -cur_pos.x + font_h);
+//    }
+//
+//    lv_style_int_t right = lv_obj_get_style_pad_right(ta, LV_TEXTAREA_PART_MAIN);
+//    lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_MAIN);
+//    /*Check the right (use the font_h as general unit)*/
+//    if(label_cords.x1 + cur_pos.x + font_h + right > ta_cords.x2) {
+//        lv_obj_set_x(label_par, -(cur_pos.x - lv_obj_get_width(ta) + font_h + left + right));
+//    }
 
     ext->cursor.valid_x = cur_pos.x;
 
@@ -757,27 +718,20 @@ void lv_textarea_set_one_line(lv_obj_t * ta, bool en)
     lv_label_align_t old_align = lv_label_get_align(ext->label);
 
     if(en) {
-        lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_BG);
-        lv_style_int_t bottom = lv_obj_get_style_pad_bottom(ta, LV_TEXTAREA_PART_BG);
-        lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_BG);
-        const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
+        const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
         lv_coord_t font_h              = lv_font_get_line_height(font);
 
         ext->one_line = 1;
-        lv_page_set_scrollable_fit2(ta, LV_FIT_MAX, LV_FIT_PARENT);
-        lv_obj_set_height(ta, font_h + top + bottom);
+        lv_obj_set_content_height(ta, font_h);
         lv_label_set_long_mode(ext->label, LV_LABEL_LONG_EXPAND);
-        lv_obj_set_pos(lv_page_get_scrollable(ta), left, top);
+        lv_obj_scroll_to(ta, 0, 0, LV_ANIM_OFF);
     }
     else {
-        lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_BG);
-        lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_BG);
         ext->one_line = 0;
-        lv_page_set_scrollable_fit2(ta, LV_FIT_PARENT, LV_FIT_TIGHT);
         lv_label_set_long_mode(ext->label, LV_LABEL_LONG_BREAK);
 
         lv_obj_set_height(ta, LV_TEXTAREA_DEF_HEIGHT);
-        lv_obj_set_pos(lv_page_get_scrollable(ta), left, top);
+        lv_obj_scroll_to(ta, 0, 0, LV_ANIM_OFF);
     }
 
     /* `refr_cursor_area` is called at the end of lv_ta_set_text_align */
@@ -804,15 +758,13 @@ void lv_textarea_set_text_align(lv_obj_t * ta, lv_label_align_t align)
         /*Normal left align. Just let the text expand*/
         if(align == LV_LABEL_ALIGN_LEFT) {
             lv_label_set_long_mode(label, LV_LABEL_LONG_EXPAND);
-            lv_page_set_scrollable_fit2(ta, LV_FIT_MAX, LV_FIT_PARENT);
             lv_label_set_align(label, align);
         }
         /*Else use fix label width equal to the Text area width*/
         else {
             lv_label_set_long_mode(label, LV_LABEL_LONG_CROP);
-            lv_obj_set_width(label, lv_page_get_width_fit(ta));
+            lv_obj_set_width(label, lv_obj_get_width_fit(ta));
             lv_label_set_align(label, align);
-            lv_page_set_scrollable_fit2(ta, LV_FIT_PARENT, LV_FIT_PARENT);
         }
     }
 
@@ -1227,8 +1179,8 @@ void lv_textarea_cursor_down(lv_obj_t * ta)
 
     /*Increment the y with one line and keep the valid x*/
 
-    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_BG);
-    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
+    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_MAIN);
+    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
     lv_coord_t font_h              = lv_font_get_line_height(font);
     pos.y += font_h + line_space + 1;
     pos.x = ext->cursor.valid_x;
@@ -1259,8 +1211,8 @@ void lv_textarea_cursor_up(lv_obj_t * ta)
     lv_label_get_letter_pos(ext->label, lv_textarea_get_cursor_pos(ta), &pos);
 
     /*Decrement the y with one line and keep the valid x*/
-    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_BG);
-    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
+    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_MAIN);
+    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
     lv_coord_t font_h              = lv_font_get_line_height(font);
     pos.y -= font_h + line_space - 1;
     pos.x = ext->cursor.valid_x;
@@ -1295,103 +1247,16 @@ static lv_design_res_t lv_textarea_design(lv_obj_t * ta, const lv_area_t * clip_
     else if(mode == LV_DESIGN_DRAW_MAIN) {
         /*Draw the object*/
         ancestor_design(ta, clip_area, mode);
+        draw_placeholder(ta, clip_area);
 
     }
     else if(mode == LV_DESIGN_DRAW_POST) {
         ancestor_design(ta, clip_area, mode);
+        draw_cursor(ta, clip_area);
     }
     return LV_DESIGN_RES_OK;
 }
 
-/**
- * An extended scrollable design of the page. Calls the normal design function and draws a cursor.
- * @param scrl pointer to the scrollable part of the Text area
- * @param clip_area  the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW_MAIN: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @return return true/false, depends on 'mode'
- */
-static lv_design_res_t lv_textarea_scrollable_design(lv_obj_t * scrl, const lv_area_t * clip_area,
-                                                     lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-        /*Return false if the object is not covers the mask_p area*/
-        return scrl_design(scrl, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        /*Draw the object*/
-        scrl_design(scrl, clip_area, mode);
-    }
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        scrl_design(scrl, clip_area, mode);
-
-        lv_obj_t * ta     = lv_obj_get_parent(scrl);
-        lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
-        const char * txt = lv_label_get_text(ext->label);
-
-        /*Draw the place holder*/
-        if(txt[0] == '\0' && ext->placeholder_txt && ext->placeholder_txt[0] != 0) {
-            lv_draw_label_dsc_t ph_dsc;
-            lv_draw_label_dsc_init(&ph_dsc);
-            lv_obj_init_draw_label_dsc(ta, LV_TEXTAREA_PART_PLACEHOLDER, &ph_dsc);
-            switch(lv_label_get_align(ext->label)) {
-                case LV_LABEL_ALIGN_CENTER:
-                    ph_dsc.flag |= LV_TXT_FLAG_CENTER;
-                    break;
-                case LV_LABEL_ALIGN_RIGHT:
-                    ph_dsc.flag |= LV_TXT_FLAG_RIGHT;
-                    break;
-                default:
-                    break;
-            }
-
-            if(ext->one_line) ph_dsc.flag |= LV_TXT_FLAG_EXPAND;
-
-            lv_draw_label(&scrl->coords, clip_area, &ph_dsc, ext->placeholder_txt, NULL);
-        }
-
-        /*Draw the cursor*/
-
-        if(ext->cursor.hidden || ext->cursor.state == 0) {
-            return LV_DESIGN_RES_OK; /*The cursor is not visible now*/
-        }
-
-        lv_draw_rect_dsc_t cur_dsc;
-        lv_draw_rect_dsc_init(&cur_dsc);
-        lv_obj_init_draw_rect_dsc(ta, LV_TEXTAREA_PART_CURSOR, &cur_dsc);
-
-        /*Draw he cursor according to the type*/
-        lv_area_t cur_area;
-        lv_area_copy(&cur_area, &ext->cursor.area);
-
-        cur_area.x1 += ext->label->coords.x1;
-        cur_area.y1 += ext->label->coords.y1;
-        cur_area.x2 += ext->label->coords.x1;
-        cur_area.y2 += ext->label->coords.y1;
-
-        lv_draw_rect(&cur_area, clip_area, &cur_dsc);
-
-        char letter_buf[8] = {0};
-        _lv_memcpy(letter_buf, &txt[ext->cursor.txt_byte_pos], _lv_txt_encoded_size(&txt[ext->cursor.txt_byte_pos]));
-
-        if(cur_dsc.bg_opa == LV_OPA_COVER) {
-            lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_CURSOR);
-            lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_CURSOR);
-            cur_area.x1 += left;
-            cur_area.y1 += top;
-
-            lv_draw_label_dsc_t cur_label_dsc;
-            lv_draw_label_dsc_init(&cur_label_dsc);
-            lv_obj_init_draw_label_dsc(ta, LV_TEXTAREA_PART_CURSOR, &cur_label_dsc);
-            lv_draw_label(&cur_area, clip_area, &cur_label_dsc, letter_buf, NULL);
-        }
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
 /**
  * Signal function of the text area
  * @param ta pointer to a text area object
@@ -1402,41 +1267,38 @@ static lv_design_res_t lv_textarea_scrollable_design(lv_obj_t * scrl, const lv_a
 static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param)
 {
     lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_textarea_get_style(ta, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(ta, sign, param);
-    }
-    else if(sign == LV_SIGNAL_GET_STATE_DSC) {
-        return ancestor_signal(ta, sign, param);
-    }
-
     /* Include the ancient signal function */
     res = ancestor_signal(ta, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
-    if(sign == LV_SIGNAL_CLEANUP) {
+
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_GET_STYLE) {
+        lv_get_style_info_t * info = param;
+        info->result = lv_textarea_get_style(ta, info->part);
+        if(info->result != NULL) return LV_RES_OK;
+    }
+    else if(sign == LV_SIGNAL_CLEANUP) {
         if(ext->pwd_tmp != NULL) lv_mem_free(ext->pwd_tmp);
         if(ext->placeholder_txt != NULL) lv_mem_free(ext->placeholder_txt);
 
         ext->pwd_tmp = NULL;
         ext->placeholder_txt = NULL;
 
-        lv_obj_clean_style_list(ta, LV_TEXTAREA_PART_CURSOR);
-        lv_obj_clean_style_list(ta, LV_TEXTAREA_PART_PLACEHOLDER);
+        _lv_obj_reset_style_list_no_refr(ta, LV_TEXTAREA_PART_CURSOR);
+        _lv_obj_reset_style_list_no_refr(ta, LV_TEXTAREA_PART_PLACEHOLDER);
 
         /* (The created label will be deleted automatically) */
-
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         if(ext->label) {
             if(ext->one_line) {
-                lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_BG);
-                lv_style_int_t bottom = lv_obj_get_style_pad_bottom(ta, LV_TEXTAREA_PART_BG);
-                const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
+                lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_MAIN);
+                lv_style_int_t bottom = lv_obj_get_style_pad_bottom(ta, LV_TEXTAREA_PART_MAIN);
+                const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
 
                 /*In one line mode refresh the Text Area height because 'vpad' can modify it*/
                 lv_coord_t font_h              = lv_font_get_line_height(font);
@@ -1445,7 +1307,7 @@ static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param
             }
             else {
                 /*In not one line mode refresh the Label width because 'hpad' can modify it*/
-                lv_obj_set_width(ext->label, lv_page_get_width_fit(ta));
+                lv_obj_set_width(ext->label, lv_obj_get_width_fit(ta));
                 lv_obj_set_pos(ext->label, 0, 0); /*Be sure the Label is in the correct position*/
 
             }
@@ -1457,7 +1319,7 @@ static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param
         /*Set the label width according to the text area width*/
         if(ext->label) {
             if(lv_obj_get_width(ta) != lv_area_get_width(param) || lv_obj_get_height(ta) != lv_area_get_height(param)) {
-                lv_obj_set_width(ext->label, lv_page_get_width_fit(ta));
+                lv_obj_set_width(ext->label, lv_obj_get_width_fit(ta));
                 lv_obj_set_pos(ext->label, 0, 0);
                 lv_label_set_text(ext->label, NULL); /*Refresh the label*/
 
@@ -1504,57 +1366,6 @@ static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param
     return res;
 }
 
-/**
- * Signal function of the scrollable part of the text area
- * @param scrl pointer to scrollable part of a text area object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_textarea_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = scrl_signal(scrl, sign, param);
-
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
-
-    lv_obj_t * ta     = lv_obj_get_parent(scrl);
-    lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
-
-    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
-        /*Set ext. size because the cursor might be out of this object*/
-        lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_BG);
-        const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
-        lv_coord_t font_h              = lv_font_get_line_height(font);
-        scrl->ext_draw_pad             = LV_MATH_MAX(scrl->ext_draw_pad, line_space + font_h);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        /*Set the label width according to the text area width*/
-        if(ext->label) {
-            if(lv_obj_get_width(scrl) != lv_area_get_width(param) ||
-               lv_obj_get_height(scrl) != lv_area_get_height(param)) {
-
-                lv_obj_set_width(ext->label, lv_page_get_width_fit(ta));
-                lv_obj_set_pos(ext->label, 0, 0);
-
-                lv_label_set_text(ext->label, NULL); /*Refresh the label*/
-                refr_cursor_area(ta);
-            }
-
-        }
-
-    }
-    else if(sign == LV_SIGNAL_PRESSING || sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_PRESS_LOST ||
-            sign == LV_SIGNAL_RELEASED) {
-        update_cursor_position_on_click(ta, sign, (lv_indev_t *)param);
-    }
-
-    return res;
-}
-
 /**
  * Get the style descriptor of a part of the object
  * @param page pointer the object
@@ -1569,20 +1380,12 @@ static lv_style_list_t * lv_textarea_get_style(lv_obj_t * ta, uint8_t part)
     lv_style_list_t * style_dsc_p;
 
     switch(part) {
-        case LV_TEXTAREA_PART_BG:
+        case LV_TEXTAREA_PART_MAIN:
             style_dsc_p = &ta->style_list;
             break;
-        case LV_TEXTAREA_PART_SCROLLBAR:
-            style_dsc_p = &ext->page.scrlbar.style;
-            break;
         case LV_TEXTAREA_PART_CURSOR:
             style_dsc_p = &ext->cursor.style;
             break;
-#if LV_USE_ANIMATION
-        case LV_TEXTAREA_PART_EDGE_FLASH:
-            style_dsc_p = &ext->page.edge_flash.style;
-            break;
-#endif
         case LV_TEXTAREA_PART_PLACEHOLDER:
             style_dsc_p = &ext->style_placeholder;
             break;
@@ -1654,7 +1457,7 @@ static void pwd_char_hider(lv_obj_t * ta)
         if(enc_len == 0) return;
 
         /*If the textarea's font has "bullet" character use it else fallback to "*"*/
-        const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
+        const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
         lv_font_glyph_dsc_t g;
         bool has_bullet;
         has_bullet = lv_font_get_glyph_dsc(font, &g, LV_TEXTAREA_PWD_BULLET_UNICODE, 0);
@@ -1715,8 +1518,8 @@ static void refr_cursor_area(lv_obj_t * ta)
 {
     lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
 
-    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_BG);
-    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_BG);
+    const lv_font_t * font = lv_obj_get_style_text_font(ta, LV_TEXTAREA_PART_MAIN);
+    lv_style_int_t line_space = lv_obj_get_style_text_line_space(ta, LV_TEXTAREA_PART_MAIN);
 
     uint32_t cur_pos = lv_textarea_get_cursor_pos(ta);
     const char * txt = lv_label_get_text(ext->label);
@@ -1796,7 +1599,6 @@ static void refr_cursor_area(lv_obj_t * ta)
 
 static void update_cursor_position_on_click(lv_obj_t * ta, lv_signal_t sign, lv_indev_t * click_source)
 {
-
     if(click_source == NULL) return;
 
     lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
@@ -1926,4 +1728,72 @@ static lv_res_t insert_handler(lv_obj_t * ta, const char * txt)
     return LV_RES_OK;
 }
 
+static void draw_placeholder(lv_obj_t * ta, const lv_area_t * clip_area)
+{
+    lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
+    const char * txt = lv_label_get_text(ext->label);
+
+    /*Draw the place holder*/
+    if(txt[0] == '\0' && ext->placeholder_txt && ext->placeholder_txt[0] != 0) {
+        lv_draw_label_dsc_t ph_dsc;
+        lv_draw_label_dsc_init(&ph_dsc);
+        lv_obj_init_draw_label_dsc(ta, LV_TEXTAREA_PART_PLACEHOLDER, &ph_dsc);
+        switch(lv_label_get_align(ext->label)) {
+        case LV_LABEL_ALIGN_CENTER:
+            ph_dsc.flag |= LV_TXT_FLAG_CENTER;
+            break;
+        case LV_LABEL_ALIGN_RIGHT:
+            ph_dsc.flag |= LV_TXT_FLAG_RIGHT;
+            break;
+        default:
+            break;
+        }
+
+        if(ext->one_line) ph_dsc.flag |= LV_TXT_FLAG_EXPAND;
+
+        lv_draw_label(&ta->coords, clip_area, &ph_dsc, ext->placeholder_txt, NULL);
+    }
+}
+
+static void draw_cursor(lv_obj_t * ta, const lv_area_t * clip_area)
+{
+    lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
+    const char * txt = lv_label_get_text(ext->label);
+
+    /*Draw the cursor*/
+    if(ext->cursor.hidden || ext->cursor.state == 0) {
+        return; /*The cursor is not visible now*/
+    }
+
+    lv_draw_rect_dsc_t cur_dsc;
+    lv_draw_rect_dsc_init(&cur_dsc);
+    lv_obj_init_draw_rect_dsc(ta, LV_TEXTAREA_PART_CURSOR, &cur_dsc);
+
+    /*Draw he cursor according to the type*/
+    lv_area_t cur_area;
+    lv_area_copy(&cur_area, &ext->cursor.area);
+
+    cur_area.x1 += ext->label->coords.x1;
+    cur_area.y1 += ext->label->coords.y1;
+    cur_area.x2 += ext->label->coords.x1;
+    cur_area.y2 += ext->label->coords.y1;
+
+    lv_draw_rect(&cur_area, clip_area, &cur_dsc);
+
+    char letter_buf[8] = {0};
+    _lv_memcpy(letter_buf, &txt[ext->cursor.txt_byte_pos], _lv_txt_encoded_size(&txt[ext->cursor.txt_byte_pos]));
+
+    if(cur_dsc.bg_opa == LV_OPA_COVER) {
+        lv_style_int_t left = lv_obj_get_style_pad_left(ta, LV_TEXTAREA_PART_CURSOR);
+        lv_style_int_t top = lv_obj_get_style_pad_top(ta, LV_TEXTAREA_PART_CURSOR);
+        cur_area.x1 += left;
+        cur_area.y1 += top;
+
+        lv_draw_label_dsc_t cur_label_dsc;
+        lv_draw_label_dsc_init(&cur_label_dsc);
+        lv_obj_init_draw_label_dsc(ta, LV_TEXTAREA_PART_CURSOR, &cur_label_dsc);
+        lv_draw_label(&cur_area, clip_area, &cur_label_dsc, letter_buf, NULL);
+    }
+}
+
 #endif
diff --git a/src/lv_widgets/lv_textarea.h b/src/lv_widgets/lv_textarea.h
index dbca0db45..0141d85e8 100644
--- a/src/lv_widgets/lv_textarea.h
+++ b/src/lv_widgets/lv_textarea.h
@@ -18,16 +18,11 @@ extern "C" {
 #if LV_USE_TEXTAREA != 0
 
 /*Testing of dependencies*/
-#if LV_USE_PAGE == 0
-#error "lv_ta: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE  1) "
-#endif
-
 #if LV_USE_LABEL == 0
 #error "lv_ta: lv_label is required. Enable it in lv_conf.h (LV_USE_LABEL  1) "
 #endif
 
 #include "../lv_core/lv_obj.h"
-#include "lv_page.h"
 #include "lv_label.h"
 
 /*********************
@@ -43,7 +38,6 @@ LV_EXPORT_CONST_INT(LV_TEXTAREA_CURSOR_LAST);
 
 /*Data of text area*/
 typedef struct {
-    lv_page_ext_t page; /*Ext. of ancestor*/
     /*New data for this type */
     lv_obj_t * label;            /*Label of the text area*/
     char * placeholder_txt;      /*Place holder label. only visible if text is an empty string*/
@@ -77,15 +71,12 @@ typedef struct {
 
 /** Possible text areas styles. */
 enum {
-    LV_TEXTAREA_PART_BG = LV_PAGE_PART_BG, /**< Text area background style */
-    LV_TEXTAREA_PART_SCROLLBAR = LV_PAGE_PART_SCROLLBAR, /**< Scrollbar style */
-    LV_TEXTAREA_PART_EDGE_FLASH = LV_PAGE_PART_EDGE_FLASH, /**< Edge flash style */
-    LV_TEXTAREA_PART_CURSOR = _LV_PAGE_PART_VIRTUAL_LAST, /**< Cursor style */
+    LV_TEXTAREA_PART_MAIN,        /**< Text area background style */
+    LV_TEXTAREA_PART_CURSOR,      /**< Cursor style */
     LV_TEXTAREA_PART_PLACEHOLDER, /**< Placeholder style */
     _LV_TEXTAREA_PART_VIRTUAL_LAST,
-
-    _LV_TEXTAREA_PART_REAL_LAST = _LV_PAGE_PART_REAL_LAST,
 };
+
 typedef uint8_t lv_textarea_style_t;
 
 /**********************
@@ -219,37 +210,6 @@ void lv_textarea_set_max_length(lv_obj_t * ta, uint32_t num);
  */
 void lv_textarea_set_insert_replace(lv_obj_t * ta, const char * txt);
 
-/**
- * Set the scroll bar mode of a text area
- * @param ta pointer to a text area object
- * @param sb_mode the new mode from 'lv_scrollbar_mode_t' enum
- */
-static inline void lv_textarea_set_scrollbar_mode(lv_obj_t * ta, lv_scrollbar_mode_t mode)
-{
-    lv_page_set_scrollbar_mode(ta, mode);
-}
-
-/**
- * Enable the scroll propagation feature. If enabled then the Text area will move its parent if
- * there is no more space to scroll.
- * @param ta pointer to a Text area
- * @param en true or false to enable/disable scroll propagation
- */
-static inline void lv_textarea_set_scroll_propagation(lv_obj_t * ta, bool en)
-{
-    lv_page_set_scroll_propagation(ta, en);
-}
-
-/**
- * Enable the edge flash effect. (Show an arc when the an edge is reached)
- * @param page pointer to a Text Area
- * @param en true or false to enable/disable end flash
- */
-static inline void lv_textarea_set_edge_flash(lv_obj_t * ta, bool en)
-{
-    lv_page_set_edge_flash(ta, en);
-}
-
 /**
  * Enable/disable selection mode.
  * @param ta pointer to a text area object
@@ -345,36 +305,6 @@ const char * lv_textarea_get_accepted_chars(lv_obj_t * ta);
  */
 uint32_t lv_textarea_get_max_length(lv_obj_t * ta);
 
-/**
- * Get the scroll bar mode of a text area
- * @param ta pointer to a text area object
- * @return scrollbar mode from 'lv_scrollbar_mode_t' enum
- */
-static inline lv_scrollbar_mode_t lv_textarea_get_scrollbar_mode(const lv_obj_t * ta)
-{
-    return lv_page_get_scrollbar_mode(ta);
-}
-
-/**
- * Get the scroll propagation property
- * @param ta pointer to a Text area
- * @return true or false
- */
-static inline bool lv_textarea_get_scroll_propagation(lv_obj_t * ta)
-{
-    return lv_page_get_scroll_propagation(ta);
-}
-
-/**
- * Get the scroll propagation property
- * @param ta pointer to a Text area
- * @return true or false
- */
-static inline bool lv_textarea_get_edge_flash(lv_obj_t * ta)
-{
-    return lv_page_get_edge_flash(ta);
-}
-
 /**
  * Find whether text is selected or not.
  * @param ta Text area object

From 301859b978463b698ad609b4466ae500d8327dff Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 30 Sep 2020 21:17:25 +0200
Subject: [PATCH 46/84] handle LV_OBJ_FLAG_SCROLL_ELASTIC/MOMENTUM

---
 src/lv_core/lv_indev_scroll.c | 57 ++++++++++++++---------
 src/lv_core/lv_obj.c          |  2 +
 src/lv_core/lv_obj_style.c    |  4 ++
 src/lv_font/lv_font_loader.c  |  2 +-
 src/lv_widgets/lv_line.c      | 88 ++++++++++++-----------------------
 src/lv_widgets/lv_line.h      | 16 -------
 src/lv_widgets/lv_table.c     |  6 ++-
 7 files changed, 77 insertions(+), 98 deletions(-)

diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 2cedf81a7..11469f4e2 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -12,6 +12,7 @@
 /*********************
  *      DEFINES
  *********************/
+#define ELASTIC_SLOWNESS_FACTOR 4   /*Scrolling on elastic parts are slower by this factor*/
 
 /**********************
  *      TYPEDEFS
@@ -26,6 +27,7 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
 static void scroll_limit_diff(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y);
 static lv_coord_t scroll_throw_predict_y(lv_indev_proc_t * proc);
 static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc);
+static lv_coord_t elastic_diff(lv_obj_t * obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end);
 
 /**********************
  *  STATIC VARIABLES
@@ -219,16 +221,15 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
         lv_coord_t diff_y = 0;
 
         if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
-            diff_x = proc->types.pointer.vect.x;
-            if(lv_obj_get_scroll_right(scroll_obj) < 0) diff_x = diff_x / 2;
-            if(lv_obj_get_scroll_left(scroll_obj) < 0) diff_x = diff_x / 2;
+            lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
+            lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
+            diff_x = elastic_diff(scroll_obj, proc->types.pointer.vect.x, sl, sr);
         } else {
-            diff_y = proc->types.pointer.vect.y;
-            if(lv_obj_get_scroll_top(scroll_obj) < 0) diff_y = diff_y / 2;
-            if(lv_obj_get_scroll_bottom(scroll_obj) < 0) diff_y = diff_y / 2;
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
+            lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+            diff_y = elastic_diff(scroll_obj, proc->types.pointer.vect.y, st, sb);
         }
 
-
         if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
         if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
         if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
@@ -252,27 +253,28 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
 {
     lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
     if(scroll_obj == NULL) return;
+    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) return;
+
 
     lv_indev_t * indev_act = lv_indev_get_act();
     lv_coord_t scroll_throw =  indev_act->driver.scroll_throw;
 
-    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_NONE) {
-        return;
+    if(lv_obj_has_flag(scroll_obj, LV_OBJ_FLAG_SCROLL_MOMENTUM) == false) {
+        proc->types.pointer.scroll_throw_vect.y = 0;
+        proc->types.pointer.scroll_throw_vect.x = 0;
     }
-    else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
+
+    if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
         proc->types.pointer.scroll_throw_vect.x = 0;
         /*If no snapping "throw"*/
         if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
             proc->types.pointer.scroll_throw_vect.y =
                     proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
 
-            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
+            lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
 
-            /*If scrolled inside reduce faster*/
-            if(st < 0 || sb < 0) {
-                proc->types.pointer.scroll_throw_vect.y = proc->types.pointer.scroll_throw_vect.y >> 1;
-            }
+             proc->types.pointer.scroll_throw_vect.y = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.y, st, sb);
 
             _lv_obj_scroll_by_raw(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y);
         }
@@ -295,10 +297,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
             lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
             lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
 
-            /*If scrolled inside reduce faster*/
-            if(sl < 0 || sr < 0) {
-                proc->types.pointer.scroll_throw_vect.x = proc->types.pointer.scroll_throw_vect.x >> 1;
-            }
+            proc->types.pointer.scroll_throw_vect.x = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.x, sl ,sr);
 
             _lv_obj_scroll_by_raw(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0);
         }
@@ -344,12 +343,13 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
             }
         }
 
-        proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
-        proc->types.pointer.scroll_obj = NULL;
         lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_END, indev_act);
         if(proc->reset_query) return;
         lv_event_send(scroll_obj, LV_EVENT_SCROLL_END, indev_act);
         if(proc->reset_query) return;
+
+        proc->types.pointer.scroll_dir = LV_SCROLL_DIR_NONE;
+        proc->types.pointer.scroll_obj = NULL;
     }
 }
 
@@ -531,3 +531,18 @@ static lv_coord_t scroll_throw_predict_x(lv_indev_proc_t * proc)
     return move;
 }
 
+static lv_coord_t elastic_diff(lv_obj_t * obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end)
+{
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_ELASTIC)) {
+        /*Elastic scroll if scrolled in*/
+        if(scroll_end < 0) diff = (diff + ELASTIC_SLOWNESS_FACTOR / 2) / ELASTIC_SLOWNESS_FACTOR;
+        else if(scroll_start < 0) diff = (diff + ELASTIC_SLOWNESS_FACTOR / 2) / ELASTIC_SLOWNESS_FACTOR;
+    } else {
+        /*Scroll back to the boundary id required*/
+        if(scroll_end + diff < 0) diff = - scroll_end;
+        if(scroll_start - diff < 0) diff = scroll_start;
+    }
+
+    return diff;
+}
+
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 8121d0011..595399dd0 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -289,6 +289,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
     new_obj->flags |= LV_OBJ_FLAG_CLICK_FOCUSABLE;
     new_obj->flags |= LV_OBJ_FLAG_SCROLLABLE;
+    new_obj->flags |= LV_OBJ_FLAG_SCROLL_ELASTIC;
+    new_obj->flags |= LV_OBJ_FLAG_SCROLL_MOMENTUM;
     if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
     new_obj->scroll.x = 0;
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index ceca453a0..16b4d49cb 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -438,6 +438,9 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
                 case LV_STYLE_VALUE_BLEND_MODE:
                     if(list->blend_mode_all_normal) def = true;
                     break;
+                case LV_STYLE_TEXT_DECOR:
+                     if(list->text_decor_none) def = true;
+                     break;
             }
 
             if(def) {
@@ -1346,6 +1349,7 @@ static bool style_prop_is_cacheable(lv_style_property_t prop)
         case LV_STYLE_TEXT_LETTER_SPACE:
         case LV_STYLE_TEXT_LINE_SPACE:
         case LV_STYLE_TEXT_FONT:
+        case LV_STYLE_TEXT_DECOR:
         case LV_STYLE_TRANSFORM_ANGLE:
         case LV_STYLE_TRANSFORM_WIDTH:
         case LV_STYLE_TRANSFORM_HEIGHT:
diff --git a/src/lv_font/lv_font_loader.c b/src/lv_font/lv_font_loader.c
index ba89955a6..7cde8370d 100644
--- a/src/lv_font/lv_font_loader.c
+++ b/src/lv_font/lv_font_loader.c
@@ -512,7 +512,7 @@ static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font)
     font->line_height = font_header.ascent - font_header.descent;
     font->get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt;
     font->get_glyph_bitmap = lv_font_get_bitmap_fmt_txt;
-    font->subpx = LV_FONT_SUBPX_NONE;
+    font->subpx = font_header.subpixels_mode;
 
     font_dsc->bpp = font_header.bits_per_pixel;
     font_dsc->kern_scale = font_header.kerning_scale;
diff --git a/src/lv_widgets/lv_line.c b/src/lv_widgets/lv_line.c
index c54a0ecf5..1d7ae5b92 100644
--- a/src/lv_widgets/lv_line.c
+++ b/src/lv_widgets/lv_line.c
@@ -71,7 +71,6 @@ lv_obj_t * lv_line_create(lv_obj_t * par, const lv_obj_t * copy)
 
     ext->point_num   = 0;
     ext->point_array = NULL;
-    ext->auto_size   = 1;
     ext->y_inv       = 0;
 
     lv_obj_set_design_cb(line, lv_line_design);
@@ -79,23 +78,19 @@ lv_obj_t * lv_line_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new line*/
     if(copy == NULL) {
-        lv_obj_set_size(line, LV_DPI,
-                        LV_DPI);          /*Auto size is enables, but set default size until no points are added*/
-
-        lv_obj_set_click(line, false);
+        lv_obj_set_size(line, LV_SIZE_AUTO, LV_SIZE_AUTO);
+        lv_obj_clear_flag(line, LV_OBJ_FLAG_CLICKABLE);
 
         lv_theme_apply(line, LV_THEME_LINE);
     }
     /*Copy an existing object*/
     else {
         lv_line_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        lv_line_set_auto_size(line, lv_line_get_auto_size(copy));
         lv_line_set_y_invert(line, lv_line_get_y_invert(copy));
-        lv_line_set_auto_size(line, lv_line_get_auto_size(copy));
         lv_line_set_points(line, copy_ext->point_array, copy_ext->point_num);
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(line, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(line, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("line created");
@@ -122,41 +117,11 @@ void lv_line_set_points(lv_obj_t * line, const lv_point_t point_a[], uint16_t po
     ext->point_array    = point_a;
     ext->point_num      = point_num;
 
-    if(point_num > 0 && ext->auto_size != 0) {
-        uint16_t i;
-        lv_coord_t xmax = LV_COORD_MIN;
-        lv_coord_t ymax = LV_COORD_MIN;
-        for(i = 0; i < point_num; i++) {
-            xmax = LV_MATH_MAX(point_a[i].x, xmax);
-            ymax = LV_MATH_MAX(point_a[i].y, ymax);
-        }
-
-        lv_style_int_t line_width = lv_obj_get_style_line_width(line, LV_LINE_PART_MAIN);
-        lv_obj_set_size(line, xmax + line_width, ymax + line_width);
-    }
+    _lv_obj_handle_self_size_chg(line);
 
     lv_obj_invalidate(line);
 }
 
-/**
- * Enable (or disable) the auto-size option. The size of the object will fit to its points.
- * (set width to x max and height to y max)
- * @param line pointer to a line object
- * @param en true: auto size is enabled, false: auto size is disabled
- */
-void lv_line_set_auto_size(lv_obj_t * line, bool en)
-{
-    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
-
-    lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
-    if(ext->auto_size == en) return;
-
-    ext->auto_size = en == false ? 0 : 1;
-
-    /*Refresh the object*/
-    if(en) lv_line_set_points(line, ext->point_array, ext->point_num);
-}
-
 /**
  * Enable (or disable) the y coordinate inversion.
  * If enabled then y will be subtracted from the height of the object,
@@ -180,20 +145,6 @@ void lv_line_set_y_invert(lv_obj_t * line, bool en)
  * Getter functions
  *====================*/
 
-/**
- * Get the auto size attribute
- * @param line pointer to a line object
- * @return true: auto size is enabled, false: disabled
- */
-bool lv_line_get_auto_size(const lv_obj_t * line)
-{
-    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
-
-    lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
-
-    return ext->auto_size == 0 ? false : true;
-}
-
 /**
  * Get the y inversion attribute
  * @param line pointer to a line object
@@ -234,8 +185,8 @@ static lv_design_res_t lv_line_design(lv_obj_t * line, const lv_area_t * clip_ar
 
         lv_area_t area;
         lv_obj_get_coords(line, &area);
-        lv_coord_t x_ofs = area.x1;
-        lv_coord_t y_ofs = area.y1;
+        lv_coord_t x_ofs = area.x1 - lv_obj_get_scroll_top(line);
+        lv_coord_t y_ofs = area.y1 - lv_obj_get_scroll_left(line);
         lv_point_t p1;
         lv_point_t p2;
         lv_coord_t h = lv_obj_get_height(line);
@@ -280,13 +231,34 @@ static lv_res_t lv_line_signal(lv_obj_t * line, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(line, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         /*The corner of the skew lines is out of the intended area*/
         lv_style_int_t line_width = lv_obj_get_style_line_width(line, LV_LINE_PART_MAIN);
         if(line->ext_draw_pad < line_width) line->ext_draw_pad = line_width;
     }
+    else if(sign == LV_SIGNAL_GET_SELF_SIZE) {
+        lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
+
+        lv_point_t * p = param;
+        lv_coord_t w = 0;
+        lv_coord_t h = 0;
+        if(ext->point_num > 0) {
+            uint16_t i;
+            for(i = 0; i < ext->point_num; i++) {
+                w = LV_MATH_MAX(ext->point_array[i].x, w);
+                h = LV_MATH_MAX(ext->point_array[i].y, h);
+            }
+
+            lv_style_int_t line_width = lv_obj_get_style_line_width(line, LV_LINE_PART_MAIN);
+            w += line_width;
+            h += line_width;
+            p->x = w;
+            p->y = h;
+        }
+    }
 
     return res;
 }
diff --git a/src/lv_widgets/lv_line.h b/src/lv_widgets/lv_line.h
index 430a9da01..1ea0a2ad4 100644
--- a/src/lv_widgets/lv_line.h
+++ b/src/lv_widgets/lv_line.h
@@ -32,7 +32,6 @@ typedef struct {
     /*Inherited from 'base_obj' so no inherited ext.*/ /*Ext. of ancestor*/
     const lv_point_t * point_array;                    /*Pointer to an array with the points of the line*/
     uint16_t point_num;                                /*Number of points in 'point_array' */
-    uint8_t auto_size : 1;                             /*1: set obj. width to x max and obj. height to y max */
     uint8_t y_inv : 1;                                 /*1: y == 0 will be on the bottom*/
 } lv_line_ext_t;
 
@@ -66,14 +65,6 @@ lv_obj_t * lv_line_create(lv_obj_t * par, const lv_obj_t * copy);
  */
 void lv_line_set_points(lv_obj_t * line, const lv_point_t point_a[], uint16_t point_num);
 
-/**
- * Enable (or disable) the auto-size option. The size of the object will fit to its points.
- * (set width to x max and height to y max)
- * @param line pointer to a line object
- * @param en true: auto size is enabled, false: auto size is disabled
- */
-void lv_line_set_auto_size(lv_obj_t * line, bool en);
-
 /**
  * Enable (or disable) the y coordinate inversion.
  * If enabled then y will be subtracted from the height of the object,
@@ -92,13 +83,6 @@ work */
  * Getter functions
  *====================*/
 
-/**
- * Get the auto size attribute
- * @param line pointer to a line object
- * @return true: auto size is enabled, false: disabled
- */
-bool lv_line_get_auto_size(const lv_obj_t * line);
-
 /**
  * Get the y inversion attribute
  * @param line pointer to a line object
diff --git a/src/lv_widgets/lv_table.c b/src/lv_widgets/lv_table.c
index c79a64999..04e47a028 100644
--- a/src/lv_widgets/lv_table.c
+++ b/src/lv_widgets/lv_table.c
@@ -103,7 +103,8 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->row_h[0] = LV_DPI; /*It will be overwritten when the theme is applied*/
         ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
 
-        lv_obj_set_size(table, LV_SIZE_AUTO, 80);
+        lv_obj_set_size(table, 80, 80);
+//        lv_obj_set_size(table, LV_SIZE_AUTO, LV_SIZE_AUTO);
 
         lv_theme_apply(table, LV_THEME_TABLE);
     }
@@ -710,6 +711,7 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
         uint16_t cell = 0;
 
         cell_area.y2 = table->coords.y1 + bg_top - 1 - lv_obj_get_scroll_top(table);
+        lv_coord_t scroll_left = lv_obj_get_scroll_left(table);
         for(row = 0; row < ext->row_cnt; row++) {
             lv_coord_t h_row = ext->row_h[row];
 
@@ -718,7 +720,7 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
 
             if(cell_area.y1 > clip_area->y2) return LV_DESIGN_RES_OK;
 
-            cell_area.x2 = table->coords.x1 + bg_left - 1;
+            cell_area.x2 = table->coords.x1 + bg_left - 1 - scroll_left;
 
             for(col = 0; col < ext->col_cnt; col++) {
 

From da1591c10fcfa5cdfb37394eac8e0fe8534d1274 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 30 Sep 2020 21:22:22 +0200
Subject: [PATCH 47/84] rework arc

---
 src/lv_widgets/lv_arc.c | 30 +++++++++++++++---------------
 src/lv_widgets/lv_arc.h |  1 -
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/lv_widgets/lv_arc.c b/src/lv_widgets/lv_arc.c
index 67d2dc71e..03f2265b6 100644
--- a/src/lv_widgets/lv_arc.c
+++ b/src/lv_widgets/lv_arc.c
@@ -103,8 +103,7 @@ lv_obj_t * lv_arc_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new arc arc*/
     if(copy == NULL) {
-        lv_obj_set_click(arc, true);
-        lv_obj_add_protect(arc, LV_PROTECT_PRESS_LOST);
+        lv_obj_add_flag(arc, LV_OBJ_FLAG_CLICKABLE);
         lv_obj_set_ext_click_area(arc, LV_DPI / 10, LV_DPI / 10, LV_DPI / 10, LV_DPI / 10);
         lv_arc_set_value(arc, ext->min_value);
         lv_theme_apply(arc, LV_THEME_ARC);
@@ -129,7 +128,7 @@ lv_obj_t * lv_arc_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_style_list_copy(&ext->style_arc, &copy_ext->style_arc);
 
         /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(arc, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
+        _lv_obj_refresh_style(arc, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("arc created");
@@ -700,22 +699,23 @@ static lv_design_res_t lv_arc_design(lv_obj_t * arc, const lv_area_t * clip_area
 static lv_res_t lv_arc_signal(lv_obj_t * arc, lv_signal_t sign, void * param)
 {
     lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_arc_get_style(arc, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(arc, sign, param);
-    }
+
 
     /* Include the ancient signal function */
     res = ancestor_signal(arc, sign, param);
     if(res != LV_RES_OK) return res;
 
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_arc_ext_t * ext = lv_obj_get_ext_attr(arc);
-
-    if(sign == LV_SIGNAL_PRESSING) {
+    if(sign == LV_SIGNAL_GET_TYPE) {
+        return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
+    }
+    else if(sign == LV_SIGNAL_GET_STYLE) {
+        lv_get_style_info_t * info = param;
+        info->result = lv_arc_get_style(arc, info->part);
+        if(info->result != NULL) return LV_RES_OK;
+        else return ancestor_signal(arc, sign, param);
+    } else if(sign == LV_SIGNAL_PRESSING) {
         /* Only adjustable arcs can be dragged */
         if(!ext->adjustable) return res;
 
@@ -832,8 +832,8 @@ static lv_res_t lv_arc_signal(lv_obj_t * arc, lv_signal_t sign, void * param)
         }
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(arc, LV_ARC_PART_KNOB);
-        lv_obj_clean_style_list(arc, LV_ARC_PART_INDIC);
+        _lv_obj_reset_style_list_no_refr(arc, LV_ARC_PART_KNOB);
+        _lv_obj_reset_style_list_no_refr(arc, LV_ARC_PART_INDIC);
     }
 
     return res;
@@ -901,7 +901,7 @@ static void inv_arc_area(lv_obj_t * arc, uint16_t start_angle, uint16_t end_angl
     extra_area = rounded ? w / 2 + 2 : 0;
 
     if(part == LV_ARC_PART_INDIC && lv_style_list_get_style(&ext->style_knob, 0) != NULL) {
-        lv_coord_t knob_extra_size = lv_obj_get_draw_rect_ext_pad_size(arc, LV_ARC_PART_KNOB);
+        lv_coord_t knob_extra_size = _lv_obj_get_draw_rect_ext_pad_size(arc, LV_ARC_PART_KNOB);
 
         lv_coord_t knob_left = lv_obj_get_style_pad_left(arc, LV_ARC_PART_KNOB);
         lv_coord_t knob_right = lv_obj_get_style_pad_right(arc, LV_ARC_PART_KNOB);
diff --git a/src/lv_widgets/lv_arc.h b/src/lv_widgets/lv_arc.h
index 9f45184d3..8e8399e5c 100644
--- a/src/lv_widgets/lv_arc.h
+++ b/src/lv_widgets/lv_arc.h
@@ -62,7 +62,6 @@ enum {
     LV_ARC_PART_INDIC,
     LV_ARC_PART_KNOB,
     _LV_ARC_PART_VIRTUAL_LAST,
-    _LV_ARC_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
 };
 typedef uint8_t lv_arc_part_t;
 

From 4eda4d59fc3722e417bfea3333183890408dd70d Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:34:22 +0200
Subject: [PATCH 48/84] grid: add fill

---
 src/lv_core/lv_grid.c | 30 ++++++++++++++++++++++++------
 src/lv_core/lv_grid.h | 25 +++++++++++++++++--------
 2 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index df8754834..dc7623cef 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -272,27 +272,44 @@ static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
     uint32_t i;
 
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
-    bool filled = false;
-    if(grid->col_dsc_len == 1 && _GRID_IS_FILL(grid->col_dsc[0])) filled = true;
+    bool fill = false;
+    bool all = false;
+    if(grid->col_dsc_len == 1 && _GRID_IS_FILL(grid->col_dsc[0])) fill = true;
+    if(grid->col_dsc_len == 1 && _GRID_IS_REPEAT(grid->col_dsc[0])) all = true;
 
-    if(filled) {
+    if(fill) {
         lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
         /* Get number of tracks fitting to the content
          * Add the gap to cont_w because here is no gap after the last track so compensate it*/
         calc->col_num = (cont_w + grid->col_gap) / (fill_w + grid->col_gap);
-    } else {
+    }
+    if(all) {
+        calc->col_num = lv_obj_count_children(cont);
+    }
+    else {
         calc->col_num = grid->col_dsc_len;
     }
     calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
     calc->w = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
     /*If filled, it's simple: every track has fill size*/
-    if(filled) {
+    if(fill) {
         lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
         for(i = 0; i < calc->col_num; i++) {
             calc->w[i] = fill_w;
         }
-    } else {
+    }
+    /*If repeated, it's simple: every track has the "repeat size"*/
+    else if(all) {
+        lv_coord_t rep_w;
+        if(grid->col_dsc[0] == LV_GRID_REPEAT_FIT) rep_w = lv_obj_get_width_fit(cont);
+        else rep_w = _GRID_GET_REPEAT(grid->col_dsc[0]);
+
+        for(i = 0; i < calc->col_num; i++) {
+            calc->w[i] = rep_w;
+        }
+    }
+    else {
         uint32_t col_fr_cnt = 0;
         lv_coord_t grid_w = 0;
         bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
@@ -468,6 +485,7 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
                     hint->row++;
                 }
             } else {
+                hint->row++;
                 if(hint->row >= calc->row_num) {
                     hint->row = 0;
                     hint->col++;
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 331ea4302..e45749f9d 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -30,7 +30,7 @@ extern "C" {
 /**
  * Some helper defines
  * */
-#define _GRID_IS_CELL(c)        ((c) > LV_COORD_MAX ? true : false)
+#define _GRID_IS_CELL(c)        ((c) >= LV_COORD_MAX ? true : false)
 #define _GRID_CELL_SHIFT        5
 #define _GRID_CELL_MAX          ((1 << _GRID_CELL_SHIFT) - 1)
 #define _GRID_CELL_POS_MASK     ((1 << _GRID_CELL_SHIFT) - 1)
@@ -45,16 +45,26 @@ extern "C" {
 #define _GRID_CELL_SIZE_PX    0     /* The cell size is set in pixels*/
 #define _GRID_CELL_SIZE_FR    1     /* The cell size is set in free units*/
 
-#define LV_GRID_FR(x)   (LV_COORD_MAX + (x))
-#define LV_GRID_FILL(x)   (LV_COORD_MAX + 256 + (x))
+#define _GRID_FR_MAX            256
+#define _GRID_FILL_MAX          2048
+#define _GRID_REPEAT_MAX           2048
+#define _GRID_FR_START        (LV_COORD_MAX)
+#define _GRID_FILL_START      (_GRID_FR_START + _GRID_FR_MAX)
+#define _GRID_REPEAT_START    (_GRID_FILL_START + _GRID_FILL_MAX)
+
+#define LV_GRID_FR(x)     (_GRID_FR_START + (x))
+#define LV_GRID_FILL(x)   (_GRID_FILL_START + (x))
+#define LV_GRID_REPEAT(x) (_GRID_REPEAT_START + (x))
+#define LV_GRID_REPEAT_FIT (_GRID_REPEAT_START + _GRID_REPEAT_MAX - 1)
 
-#define _GRID_FR_MAX        256
 #define _GRID_IS_PX(x)      ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
-#define _GRID_IS_FR(x)      ((x) > LV_COORD_MAX && (x) <  LV_COORD_MAX + _GRID_FR_MAX ? true : false)
-#define _GRID_IS_FILL(x)    ((x) > LV_COORD_MAX + _GRID_FR_MAX ? true : false)
+#define _GRID_IS_FR(x)      ((x) > _GRID_FR_START && (x) <  _GRID_FILL_START ? true : false)
+#define _GRID_IS_FILL(x)    ((x) > _GRID_FILL_START && (x) < _GRID_REPEAT_START ? true : false)
+#define _GRID_IS_REPEAT(x)  ((x) > _GRID_REPEAT_START  ? true : false)
 #define _GRID_IS_AUTO(x)    (x == LV_GRID_AUTO ? true : false)
 #define _GRID_GET_FR(x)     ((x) - LV_COORD_MAX)
-#define _GRID_GET_FILL(x)     ((x) - LV_COORD_MAX - _GRID_FR_MAX)
+#define _GRID_GET_FILL(x)     ((x) - _GRID_FILL_START)
+#define _GRID_GET_REPEAT(x)     ((x) - _GRID_REPEAT_START)
 
 
 /**
@@ -90,7 +100,6 @@ typedef struct {
     lv_coord_t row_gap;
     uint8_t col_place;
     uint8_t row_place;
-
 }lv_grid_t;
 
 typedef struct {

From d96a2c890c3ffccad8485c82327ffed281aa075f Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:35:00 +0200
Subject: [PATCH 49/84] indev scroll clean up

---
 src/lv_core/lv_indev.c        |   2 +-
 src/lv_core/lv_indev_scroll.c | 331 +++++++++++++++++-----------------
 2 files changed, 171 insertions(+), 162 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index 94055b903..a9ca7e463 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -211,7 +211,7 @@ void lv_indev_set_cursor(lv_indev_t * indev, lv_obj_t * cur_obj)
     indev->cursor = cur_obj;
     lv_obj_set_parent(indev->cursor, lv_disp_get_layer_sys(indev->driver.disp));
     lv_obj_set_pos(indev->cursor, indev->proc.types.pointer.act_point.x, indev->proc.types.pointer.act_point.y);
-    lv_obj_add_flag(indev->cursor, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_clear_flag(indev->cursor, LV_OBJ_FLAG_CLICKABLE);
 }
 
 #if LV_USE_GROUP
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 11469f4e2..c9cd02ee2 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -21,7 +21,8 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-
+static lv_obj_t * find_scroll_obj(lv_indev_proc_t * proc);
+static void init_scroll_limits(lv_indev_proc_t * proc);
 static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs);
 static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs);
 static void scroll_limit_diff(lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y);
@@ -47,174 +48,24 @@ static lv_coord_t elastic_diff(lv_obj_t * obj, lv_coord_t diff, lv_coord_t scrol
  */
 void _lv_scroll_handler(lv_indev_proc_t * proc)
 {
-    lv_obj_t * scroll_candidate_obj = NULL;
-    lv_scroll_dir_t dirs_candidate = LV_SCROLL_DIR_NONE;
-
-    lv_indev_t * indev_act = lv_indev_get_act();
-    lv_coord_t scroll_limit =  indev_act->driver.scroll_limit;
-
+    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
     /*If there is no scroll object yet try to find one*/
-    if(proc->types.pointer.scroll_obj == NULL) {
+    if(scroll_obj == NULL) {
         proc->types.pointer.scroll_sum.x += proc->types.pointer.vect.x;
         proc->types.pointer.scroll_sum.y += proc->types.pointer.vect.y;
 
-        proc->types.pointer.scroll_obj = proc->types.pointer.act_obj;
+        scroll_obj = find_scroll_obj(proc);
+        if(scroll_obj == NULL) return;
 
-        /* Go until find an scrollable object in the current direction
-         * More precisely:
-         *  1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
-         *  2. Scrollable means it has some content out of it's area
-         *  3. If an object can be scrolled into the current direction then use it ("real match"")
-         *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
-         *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
-        while(proc->types.pointer.scroll_obj) {
-            if(lv_obj_has_flag(proc->types.pointer.scroll_obj, LV_OBJ_FLAG_SCROLLABLE) == false) {
-                proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
-                continue;
-            }
+        init_scroll_limits(proc);
 
-            /*Decide if it's a horizontal or vertical scroll*/
-            bool hor_en = false;
-            bool ver_en = false;
-            if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
-                hor_en = true;
-            }
-            else {
-                ver_en = true;
-            }
-
-            /*Consider both up-down or left/right scrollable according to the current direction*/
-            bool up_en = ver_en;
-            bool down_en = ver_en;
-            bool left_en = hor_en;
-            bool right_en = hor_en;
-
-            /*The object might have disabled some directions.*/
-            lv_dir_t scroll_dir = proc->types.pointer.scroll_obj->scroll_dir;
-            if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
-            if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
-            if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
-            if((scroll_dir & LV_DIR_BOTTOM) == 0) down_en = false;
-
-            /*The object is scrollable to a direction if its content overflow in that direction. */
-            lv_coord_t st = lv_obj_get_scroll_top(proc->types.pointer.scroll_obj);
-            lv_coord_t sb = lv_obj_get_scroll_bottom(proc->types.pointer.scroll_obj);
-            lv_coord_t sl = lv_obj_get_scroll_left(proc->types.pointer.scroll_obj);
-            lv_coord_t sr = lv_obj_get_scroll_right(proc->types.pointer.scroll_obj);
-
-            /* If this object is scrollable into the current scroll direction then save it as a candidate.
-             * It's important only to be scrollable on the current axis (hor/ver) because if the scroll
-             * is propagated to this object it can show at least elastic scroll effect.
-             * But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate) */
-            if((st > 0 || sb > 0)  &&
-              ((up_en    && proc->types.pointer.scroll_sum.y >= scroll_limit) ||
-               (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit)))
-            {
-                scroll_candidate_obj = proc->types.pointer.scroll_obj;
-                dirs_candidate = LV_SCROLL_DIR_VER;
-            }
-
-            if((sl > 0 || sr > 0)  &&
-              ((left_en    && proc->types.pointer.scroll_sum.x >=  scroll_limit) ||
-               (right_en  && proc->types.pointer.scroll_sum.x <= - scroll_limit)))
-            {
-                scroll_candidate_obj = proc->types.pointer.scroll_obj;
-                dirs_candidate = LV_SCROLL_DIR_HOR;
-            }
-
-            if(st <= 0) up_en = false;
-            if(sb <= 0) down_en = false;
-            if(sl <= 0) left_en = false;
-            if(sr <= 0) right_en = false;
-
-            /*If the object really can be scrolled into the current direction the use it. */
-            if((left_en  && proc->types.pointer.scroll_sum.x >=   scroll_limit) ||
-               (right_en && proc->types.pointer.scroll_sum.x <= - scroll_limit) ||
-               (up_en    && proc->types.pointer.scroll_sum.y >=   scroll_limit) ||
-               (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit))
-            {
-                proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
-                break;
-            }
-
-            /*Try the parent */
-            proc->types.pointer.scroll_obj = lv_obj_get_parent(proc->types.pointer.scroll_obj);
-        }
-
-        /*Use the last candidate*/
-        if(proc->types.pointer.scroll_obj == NULL) {
-            if(scroll_candidate_obj) {
-                proc->types.pointer.scroll_dir = dirs_candidate;
-                proc->types.pointer.scroll_obj = scroll_candidate_obj;
-            } else {
-                return;
-            }
-        }
-
-        proc->types.pointer.scroll_sum.x = 0;
-        proc->types.pointer.scroll_sum.y = 0;
-
-        lv_obj_t * obj = proc->types.pointer.scroll_obj;
-        /*If there no STOP allow scrolling anywhere*/
-        if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_STOP) == false) {
-            lv_area_set(&proc->types.pointer.scroll_area, LV_COORD_MIN, LV_COORD_MIN, LV_COORD_MAX, LV_COORD_MAX);
-        }
-        /*With STOP limit the scrolling to the perv and next snap point*/
-        else {
-            switch(obj->snap_align_y) {
-            case LV_SCROLL_SNAP_ALIGN_START:
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_END:
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_CENTER: {
-                lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
-                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
-                break;
-            }
-            default:
-                proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
-                proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
-                break;
-            }
-
-            switch(obj->snap_align_x) {
-            case LV_SCROLL_SNAP_ALIGN_START:
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_END:
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
-                break;
-            case LV_SCROLL_SNAP_ALIGN_CENTER: {
-                lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
-                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
-                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
-                break;
-            }
-            default:
-                proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
-                proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
-                break;
-            }
-        }
-
-        lv_signal_send(obj, LV_SIGNAL_SCROLL_BEGIN, indev_act);
+        lv_indev_t * indev_act = lv_indev_get_act();
+        lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_BEGIN, indev_act);
         if(proc->reset_query) return;
-        lv_event_send(obj, LV_EVENT_SCROLL_BEGIN, indev_act);
+        lv_event_send(scroll_obj, LV_EVENT_SCROLL_BEGIN, indev_act);
         if(proc->reset_query) return;
-
     }
 
-    /*If there is no scroll object there is nothing to do*/
-    lv_obj_t * scroll_obj = proc->types.pointer.scroll_obj;
-    if(scroll_obj == NULL) return;
-
     /*Set new position or scroll if the vector is not zero*/
     if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {
         lv_coord_t diff_x = 0;
@@ -305,13 +156,12 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
         else {
             lv_coord_t diff_x = scroll_throw_predict_x(proc);
             proc->types.pointer.scroll_throw_vect.x = 0;
-            scroll_limit_diff(proc, NULL, &diff_x);
+            scroll_limit_diff(proc, &diff_x, NULL);
             lv_coord_t x = find_snap_point_x(scroll_obj, LV_COORD_MIN, LV_COORD_MAX, diff_x);
             lv_obj_scroll_by(scroll_obj, x + diff_x, 0, LV_ANIM_ON);
         }
     }
 
-
     /*Check if the scroll has finished */
     if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
         /*Revert if scrolled in*/
@@ -388,6 +238,165 @@ lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir)
  *   STATIC FUNCTIONS
  **********************/
 
+static lv_obj_t * find_scroll_obj(lv_indev_proc_t * proc)
+{
+    lv_obj_t * obj_candidate = NULL;
+    lv_dir_t dir_candidate = LV_DIR_NONE;
+    lv_indev_t * indev_act = lv_indev_get_act();
+    lv_coord_t scroll_limit =  indev_act->driver.scroll_limit;
+
+    /* Go until find an scrollable object in the current direction
+     * More precisely:
+     *  1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
+     *  2. Scrollable means it has some content out of it's area
+     *  3. If an object can be scrolled into the current direction then use it ("real match"")
+     *  4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
+     *  5. Use the last candidate. Always the "deepest" parent or the object from point 3 */
+    lv_obj_t * obj_act = proc->types.pointer.act_obj;
+    while(obj_act) {
+        if(lv_obj_has_flag(obj_act, LV_OBJ_FLAG_SCROLLABLE) == false) {
+            obj_act = lv_obj_get_parent(obj_act);
+            continue;
+        }
+
+        /*Decide if it's a horizontal or vertical scroll*/
+        bool hor_en = false;
+        bool ver_en = false;
+        if(LV_MATH_ABS(proc->types.pointer.scroll_sum.x) > LV_MATH_ABS(proc->types.pointer.scroll_sum.y)) {
+            hor_en = true;
+        }
+        else {
+            ver_en = true;
+        }
+
+        /*Consider both up-down or left/right scrollable according to the current direction*/
+        bool up_en = ver_en;
+        bool down_en = ver_en;
+        bool left_en = hor_en;
+        bool right_en = hor_en;
+
+        /*The object might have disabled some directions.*/
+        lv_dir_t scroll_dir = obj_act->scroll_dir;
+        if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
+        if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
+        if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
+        if((scroll_dir & LV_DIR_BOTTOM) == 0) down_en = false;
+
+        /*The object is scrollable to a direction if its content overflow in that direction. */
+        lv_coord_t st = lv_obj_get_scroll_top(obj_act);
+        lv_coord_t sb = lv_obj_get_scroll_bottom(obj_act);
+        lv_coord_t sl = lv_obj_get_scroll_left(obj_act);
+        lv_coord_t sr = lv_obj_get_scroll_right(obj_act);
+
+        /* If this object is scrollable into the current scroll direction then save it as a candidate.
+         * It's important only to be scrollable on the current axis (hor/ver) because if the scroll
+         * is propagated to this object it can show at least elastic scroll effect.
+         * But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate) */
+        if((st > 0 || sb > 0)  &&
+                ((up_en    && proc->types.pointer.scroll_sum.y >= scroll_limit) ||
+                        (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit)))
+        {
+            obj_candidate = obj_act;
+            dir_candidate = LV_SCROLL_DIR_VER;
+        }
+
+        if((sl > 0 || sr > 0)  &&
+                ((left_en    && proc->types.pointer.scroll_sum.x >=  scroll_limit) ||
+                        (right_en  && proc->types.pointer.scroll_sum.x <= - scroll_limit)))
+        {
+            obj_candidate = obj_act;
+            dir_candidate = LV_SCROLL_DIR_HOR;
+        }
+
+        if(st <= 0) up_en = false;
+        if(sb <= 0) down_en = false;
+        if(sl <= 0) left_en = false;
+        if(sr <= 0) right_en = false;
+
+        /*If the object really can be scrolled into the current direction the use it. */
+        if((left_en  && proc->types.pointer.scroll_sum.x >=   scroll_limit) ||
+                (right_en && proc->types.pointer.scroll_sum.x <= - scroll_limit) ||
+                (up_en    && proc->types.pointer.scroll_sum.y >=   scroll_limit) ||
+                (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit))
+        {
+            proc->types.pointer.scroll_dir = hor_en ? LV_SCROLL_DIR_HOR : LV_SCROLL_DIR_VER;
+            break;
+        }
+
+        /*Try the parent */
+        obj_act = lv_obj_get_parent(obj_act);
+    }
+
+    /*Use the last candidate*/
+    if(obj_candidate) {
+        proc->types.pointer.scroll_dir = dir_candidate;
+        proc->types.pointer.scroll_obj = obj_candidate;
+        proc->types.pointer.scroll_sum.x = 0;
+        proc->types.pointer.scroll_sum.y = 0;
+    }
+
+    return obj_candidate;
+}
+
+static void init_scroll_limits(lv_indev_proc_t * proc)
+{
+    lv_obj_t * obj = proc->types.pointer.scroll_obj;
+    /*If there no STOP allow scrolling anywhere*/
+    if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_STOP) == false) {
+        lv_area_set(&proc->types.pointer.scroll_area, LV_COORD_MIN, LV_COORD_MIN, LV_COORD_MAX, LV_COORD_MAX);
+    }
+    /*With STOP limit the scrolling to the perv and next snap point*/
+    else {
+        switch(obj->snap_align_y) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER: {
+            lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
+            break;
+        }
+        default:
+            proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
+            proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
+            break;
+        }
+
+        switch(obj->snap_align_x) {
+        case LV_SCROLL_SNAP_ALIGN_START:
+            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
+            break;
+        case LV_SCROLL_SNAP_ALIGN_END:
+            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
+            break;
+        case LV_SCROLL_SNAP_ALIGN_CENTER: {
+            lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
+            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
+            break;
+        }
+        default:
+            proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
+            proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
+            break;
+        }
+    }
+
+    /*Allow scrolling on the edges. It will be reverted to the edge due to snapping anyway*/
+    if(proc->types.pointer.scroll_area.x1 == 0) proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
+    if(proc->types.pointer.scroll_area.x2 == 0) proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
+    if(proc->types.pointer.scroll_area.y1 == 0) proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
+    if(proc->types.pointer.scroll_area.y2 == 0) proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
+}
+
 static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
 {
     if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;

From 23330511333f3891cce298f9c9fd1dbe7872d058 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:35:43 +0200
Subject: [PATCH 50/84] add btnmatrix type 2 style

---
 src/lv_widgets/lv_btnmatrix.c | 43 ++++++++++++++++++++++++-----------
 src/lv_widgets/lv_btnmatrix.h |  7 ++++--
 2 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/src/lv_widgets/lv_btnmatrix.c b/src/lv_widgets/lv_btnmatrix.c
index 4ef632efb..03ea05ed4 100644
--- a/src/lv_widgets/lv_btnmatrix.c
+++ b/src/lv_widgets/lv_btnmatrix.c
@@ -40,6 +40,7 @@ static bool button_is_inactive(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_click_trig(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_tgl_enabled(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_get_checked(lv_btnmatrix_ctrl_t ctrl_bits);
+static bool button_is_type2(lv_btnmatrix_ctrl_t ctrl_bits);
 static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p);
 static void allocate_btn_areas_and_controls(const lv_obj_t * btnm, const char ** map);
 static void invalidate_button_area(const lv_obj_t * btnm, uint16_t btn_idx);
@@ -98,6 +99,7 @@ lv_obj_t * lv_btnmatrix_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->recolor        = 0;
     ext->one_check      = 0;
     lv_style_list_init(&ext->style_btn);
+    lv_style_list_init(&ext->style_btn2);
     ext->style_btn.ignore_trans = 1;
 
     if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_cb(btnm);
@@ -198,21 +200,23 @@ void lv_btnmatrix_set_map(lv_obj_t * btnm, const char * map[])
 
         /*Set the button size and positions*/
         lv_coord_t max_w_no_gap = max_w - (col_gap * (btn_cnt - 1));
+        if(max_w_no_gap < 0) max_w_no_gap = 0;
+
         uint32_t row_unit_cnt = 0;  /*The current unit position in the row*/
         uint32_t btn;
         for(btn = 0; btn < btn_cnt; btn++, btn_tot_i++, txt_tot_i++) {
             uint32_t btn_u = get_button_width(ext->ctrl_bits[btn_tot_i]);
 
-            lv_coord_t btn_x1 = (max_w_no_gap * row_unit_cnt) / unit_cnt + btn * col_gap;
-            lv_coord_t btn_x2 = (max_w_no_gap * (row_unit_cnt + btn_u)) / unit_cnt + btn * col_gap;
+            lv_coord_t btn_x1 = left + (max_w_no_gap * row_unit_cnt) / unit_cnt + btn * col_gap;
+            lv_coord_t btn_x2 = left + (max_w_no_gap * (row_unit_cnt + btn_u)) / unit_cnt + btn * col_gap;
 
             /*If RTL start from the right*/
             if(base_dir == LV_BIDI_DIR_RTL) {
                 lv_coord_t tmp = btn_x1;
                 btn_x1 = btn_x2;
                 btn_x2 = tmp;
-                btn_x1 = left + max_w - btn_x1;
-                btn_x2 = left + max_w - btn_x2;
+                btn_x1 = max_w - btn_x1;
+                btn_x2 = max_w - btn_x2;
             }
 
             lv_area_set(&ext->button_areas[btn_tot_i], btn_x1, row_y1, btn_x2, row_y2);
@@ -288,7 +292,7 @@ void lv_btnmatrix_set_recolor(const lv_obj_t * btnm, bool en)
  * @param btnm pointer to button matrix object
  * @param btn_id 0 based index of the button to modify. (Not counting new lines)
  */
-void lv_btnmatrix_set_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
+void lv_btnmatrix_set_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
 {
     LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
 
@@ -296,6 +300,10 @@ void lv_btnmatrix_set_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnmat
 
     if(btn_id >= ext->btn_cnt) return;
 
+    if(ext->one_check && (ctrl & LV_BTNMATRIX_CTRL_CHECKED)) {
+        lv_btnmatrix_clear_btn_ctrl_all(btnm, LV_BTNMATRIX_CTRL_CHECKED);
+    }
+
     ext->ctrl_bits[btn_id] |= ctrl;
     invalidate_button_area(btnm, btn_id);
 }
@@ -672,12 +680,13 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
                 btn_state |= LV_STATE_FOCUSED;
                 if(state_ori & LV_STATE_EDITED) btn_state |= LV_STATE_EDITED;
             }
+            bool type2 = button_is_type2(ext->ctrl_bits[btn_i]);
 
-            if(btn_state == LV_STATE_DEFAULT) {
+            if(btn_state == LV_STATE_DEFAULT && type2 == false) {
                 draw_rect_dsc_act = &draw_rect_rel_dsc;
                 draw_label_dsc_act = &draw_label_rel_dsc;
             }
-            else if(btn_state == LV_STATE_CHECKED) {
+            else if(btn_state == LV_STATE_CHECKED && type2 == false) {
                 if(!chk_inited) {
                     btnm->state = LV_STATE_CHECKED;
                     _lv_obj_disable_style_caching(btnm, true);
@@ -693,7 +702,7 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
                 draw_rect_dsc_act = &draw_rect_chk_dsc;
                 draw_label_dsc_act = &draw_label_chk_dsc;
             }
-            else if(btn_state == LV_STATE_DISABLED) {
+            else if(btn_state == LV_STATE_DISABLED && type2 == false) {
                 if(!disabled_inited) {
                     btnm->state = LV_STATE_DISABLED;
                     _lv_obj_disable_style_caching(btnm, true);
@@ -715,8 +724,8 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
                 _lv_obj_disable_style_caching(btnm, true);
                 lv_draw_rect_dsc_init(&draw_rect_tmp_dsc);
                 lv_draw_label_dsc_init(&draw_label_tmp_dsc);
-                lv_obj_init_draw_rect_dsc(btnm, LV_BTNMATRIX_PART_BTN, &draw_rect_tmp_dsc);
-                lv_obj_init_draw_label_dsc(btnm, LV_BTNMATRIX_PART_BTN, &draw_label_tmp_dsc);
+                lv_obj_init_draw_rect_dsc(btnm, type2 ? LV_BTNMATRIX_PART_BTN_2 : LV_BTNMATRIX_PART_BTN, &draw_rect_tmp_dsc);
+                lv_obj_init_draw_label_dsc(btnm, type2 ? LV_BTNMATRIX_PART_BTN_2 : LV_BTNMATRIX_PART_BTN, &draw_label_tmp_dsc);
                 draw_label_tmp_dsc.flag = txt_flag;
                 draw_rect_dsc_act = &draw_rect_tmp_dsc;
                 draw_label_dsc_act = &draw_label_tmp_dsc;
@@ -901,7 +910,6 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             invalidate_button_area(btnm, ext->btn_id_pr);
             invalidate_button_area(btnm, ext->btn_id_focused);
 
-
             lv_indev_type_t indev_type = lv_indev_get_type(lv_indev_get_act());
             if(indev_type == LV_INDEV_TYPE_KEYPAD || indev_type == LV_INDEV_TYPE_ENCODER) {
                 ext->btn_id_focused = ext->btn_id_pr;
@@ -947,7 +955,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             /*In navigation mode don't select any button but in edit mode select the fist*/
             if(lv_group_get_editing(lv_obj_get_group(btnm))) {
                 ext->btn_id_focused = 0;
-                ext->btn_id_act = ext->btn_id_focused;
+                ext->btn_id_act = 0;
             }
             else {
                 ext->btn_id_focused = LV_BTNMATRIX_BTN_NONE;
@@ -955,7 +963,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
         }
         else if(indev_type == LV_INDEV_TYPE_KEYPAD) {
             ext->btn_id_focused = 0;
-            ext->btn_id_act = ext->btn_id_focused;
+            ext->btn_id_act = 0;
         }
 
 #endif
@@ -1069,6 +1077,9 @@ static lv_style_list_t * lv_btnmatrix_get_style(lv_obj_t * btnm, uint8_t part)
         case LV_BTNMATRIX_PART_BTN:
             style_dsc_p = &ext->style_btn;
             break;
+        case LV_BTNMATRIX_PART_BTN_2:
+            style_dsc_p = &ext->style_btn2;
+            break;
         default:
             style_dsc_p = NULL;
     }
@@ -1156,6 +1167,12 @@ static bool button_get_checked(lv_btnmatrix_ctrl_t ctrl_bits)
     return (ctrl_bits & LV_BTNMATRIX_CTRL_CHECKED) ? true : false;
 }
 
+static bool button_is_type2(lv_btnmatrix_ctrl_t ctrl_bits)
+{
+    return (ctrl_bits & LV_BTNMATRIX_CTRL_TYPE_2) ? true : false;
+}
+
+
 /**
  * Gives the button id of a button under a given point
  * @param btnm pointer to a button matrix object
diff --git a/src/lv_widgets/lv_btnmatrix.h b/src/lv_widgets/lv_btnmatrix.h
index b2c332621..be636b390 100644
--- a/src/lv_widgets/lv_btnmatrix.h
+++ b/src/lv_widgets/lv_btnmatrix.h
@@ -42,6 +42,7 @@ enum {
     LV_BTNMATRIX_CTRL_CHECKABLE  = 0x0040, /**< Button *can* be toggled. */
     LV_BTNMATRIX_CTRL_CHECKED    = 0x0080, /**< Button is currently toggled (e.g. checked). */
     LV_BTNMATRIX_CTRL_CLICK_TRIG = 0x0100, /**< 1: Send LV_EVENT_VALUE_CHANGE on CLICK, 0: Send LV_EVENT_VALUE_CHANGE on PRESS*/
+    LV_BTNMATRIX_CTRL_TYPE_2 =     0x0200, /**< Render the button with `LV_BTNMATRIX_PART_BTN2` style*/
 };
 typedef uint16_t lv_btnmatrix_ctrl_t;
 
@@ -52,7 +53,8 @@ typedef struct {
     const char ** map_p;                              /*Pointer to the current map*/
     lv_area_t * button_areas;                         /*Array of areas of buttons*/
     lv_btnmatrix_ctrl_t * ctrl_bits;                       /*Array of control bytes*/
-    lv_style_list_t style_btn;                     /*Styles of buttons in each state*/
+    lv_style_list_t style_btn;                        /*Styles of buttons in each state*/
+    lv_style_list_t style_btn2;                       /*Styles of buttons in each state with LV_BTNMATRIX_CTRL_TYPE_2 control*/
     uint16_t btn_cnt;                                 /*Number of button in 'map_p'(Handled by the library)*/
     uint16_t btn_id_pr;                               /*Index of the currently pressed button or LV_BTNMATRIX_BTN_NONE*/
     uint16_t btn_id_focused;                          /*Index of the currently focused button or LV_BTNMATRIX_BTN_NONE*/
@@ -65,6 +67,7 @@ typedef struct {
 enum {
     LV_BTNMATRIX_PART_MAIN,
     LV_BTNMATRIX_PART_BTN,
+    LV_BTNMATRIX_PART_BTN_2,
 };
 typedef uint8_t lv_btnmatrix_part_t;
 
@@ -127,7 +130,7 @@ void lv_btnmatrix_set_recolor(const lv_obj_t * btnm, bool en);
  * @param btnm pointer to button matrix object
  * @param btn_id 0 based index of the button to modify. (Not counting new lines)
  */
-void lv_btnmatrix_set_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl);
+void lv_btnmatrix_set_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl);
 
 /**
  * Clear the attributes of a button of the button matrix

From 04148ade34782eccf883d29f21263d7605a52aae Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:40:33 +0200
Subject: [PATCH 51/84] table: remove debug code

---
 src/lv_widgets/lv_table.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lv_widgets/lv_table.c b/src/lv_widgets/lv_table.c
index 316d40b85..61e5bd7cf 100644
--- a/src/lv_widgets/lv_table.c
+++ b/src/lv_widgets/lv_table.c
@@ -103,9 +103,9 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
         ext->col_w[0] = LV_DPI;
         ext->row_h[0] = LV_DPI; /*It will be overwritten when the theme is applied*/
         ext->cell_data = lv_mem_realloc(ext->cell_data, ext->row_cnt * ext->col_cnt * sizeof(char *));
+        ext->cell_data[0] = NULL;
 
-        lv_obj_set_size(table, 80, 80);
-//        lv_obj_set_size(table, LV_SIZE_AUTO, LV_SIZE_AUTO);
+        lv_obj_set_size(table, LV_SIZE_AUTO, LV_SIZE_AUTO);
 
         lv_theme_apply(table, LV_THEME_TABLE);
     }

From 778c2a5cb7ed8cc96d3231f511452aad88bf9563 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:41:33 +0200
Subject: [PATCH 52/84] arc_draw: fix using large angles

---
 src/lv_draw/lv_draw_arc.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lv_draw/lv_draw_arc.c b/src/lv_draw/lv_draw_arc.c
index bcf94d000..fb11dba46 100644
--- a/src/lv_draw/lv_draw_arc.c
+++ b/src/lv_draw/lv_draw_arc.c
@@ -99,8 +99,8 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
         return;
     }
 
-    if(start_angle >= 360) start_angle -= 360;
-    if(end_angle >= 360) end_angle -= 360;
+    while(start_angle >= 360) start_angle -= 360;
+    while(end_angle >= 360) end_angle -= 360;
 
     lv_draw_mask_angle_param_t mask_angle_param;
     lv_draw_mask_angle_init(&mask_angle_param, center_x, center_y, start_angle, end_angle);

From 68058eeff1039caee9fc7e0fd12a7bd7b075f644 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 16:41:55 +0200
Subject: [PATCH 53/84] minor fixes

---
 src/lv_core/lv_obj.c     |  25 +++++---
 src/lv_core/lv_obj_pos.c | 123 +++++++++++++++++++++++++++++++++++----
 src/lv_misc/lv_anim.c    |   2 +-
 src/lv_misc/lv_mem.c     |   2 +-
 src/lv_widgets/lv_btn.c  |   1 +
 5 files changed, 133 insertions(+), 20 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 595399dd0..aa6e48880 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -48,7 +48,7 @@
 #define LV_OBJX_NAME "lv_obj"
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
-#define GRID_DEBUG  0 /*Draw rectangles on grid cells*/
+#define GRID_DEBUG  1 /*Draw rectangles on grid cells*/
 
 /**********************
  *      TYPEDEFS
@@ -1759,13 +1759,13 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
 
             uint32_t row;
             uint32_t col;
-            for(row = 0; row < calc.row_dsc_len - 1; row ++) {
-                for(col = 0; col < calc.col_dsc_len - 1; col ++) {
+            for(row = 0; row < calc.row_num; row ++) {
+                for(col = 0; col < calc.col_num; col ++) {
                     lv_area_t a;
-                    a.x1 = grid_abs.x + calc.col_dsc[col];
-                    a.x2 = grid_abs.x + calc.col_dsc[col + 1];
-                    a.y1 = grid_abs.y + calc.row_dsc[row];
-                    a.y2 = grid_abs.y + calc.row_dsc[row + 1];
+                    a.x1 = grid_abs.x + calc.x[col];
+                    a.x2 = a.x1 + calc.w[col];
+                    a.y1 = grid_abs.y + calc.y[row];
+                    a.y2 = a.y1 + calc.h[row];
                     lv_draw_rect(&a, clip_area, &grid_rect_dsc);
                 }
             }
@@ -1914,6 +1914,17 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
                 _lv_grid_full_refresh(obj);
             }
         }
+
+        /* If the parent has an implicit grid in a direction and this object (whose child has changed)
+         * is stretched in that direction then the grid of the parent might have changed because
+         * the track size of implicit grids with stretched cells is calculated from the children bounding box.*/
+        lv_obj_t * par = lv_obj_get_parent(obj);
+        if(par && _lv_obj_is_grid_item(obj) &&
+                ((par->grid->col_dsc == NULL && _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) ||
+                (par->grid->row_dsc == NULL && _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH))) {
+            _lv_grid_full_refresh(par);
+        }
+
     }
     else if(sign == LV_SIGNAL_SCROLL) {
         res = lv_event_send(obj, LV_EVENT_SCROLL, NULL);
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index e1a719fe9..ad78c3d34 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -264,19 +264,120 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 
     LV_ASSERT_OBJ(base, LV_OBJX_NAME);
 
-    lv_point_t new_pos;
-    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
+//    lv_point_t new_pos;
+//    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
 
-    /*Bring together the coordination system of base and obj*/
-    lv_obj_t * par        = lv_obj_get_parent(obj);
-    lv_coord_t par_abs_x  = par->coords.x1;
-    lv_coord_t par_abs_y  = par->coords.y1;
-    new_pos.x += x_ofs;
-    new_pos.y += y_ofs;
-    new_pos.x -= par_abs_x;
-    new_pos.y -= par_abs_y;
 
-    lv_obj_set_pos(obj, new_pos.x, new_pos.y);
+    lv_coord_t x;
+    lv_coord_t y;
+    switch(align) {
+    case LV_ALIGN_CENTER:
+        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        break;
+    case LV_ALIGN_IN_TOP_LEFT:
+        x = 0;
+        y = 0;
+        break;
+    case LV_ALIGN_IN_TOP_MID:
+        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        y = 0;
+        break;
+
+    case LV_ALIGN_IN_TOP_RIGHT:
+        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        y = 0;
+        break;
+
+    case LV_ALIGN_IN_BOTTOM_LEFT:
+        x = 0;
+        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        break;
+    case LV_ALIGN_IN_BOTTOM_MID:
+        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_IN_BOTTOM_RIGHT:
+        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_IN_LEFT_MID:
+        x = 0;
+        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        break;
+
+    case LV_ALIGN_IN_RIGHT_MID:
+        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        break;
+
+    case LV_ALIGN_OUT_TOP_LEFT:
+        x = 0;
+        y = -lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_OUT_TOP_MID:
+        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        y = -lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_OUT_TOP_RIGHT:
+        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        y = -lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_OUT_BOTTOM_LEFT:
+        x = 0;
+        y = lv_obj_get_height_fit(base);
+        break;
+
+    case LV_ALIGN_OUT_BOTTOM_MID:
+        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        y = lv_obj_get_height_fit(base);
+        break;
+
+    case LV_ALIGN_OUT_BOTTOM_RIGHT:
+        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        y = lv_obj_get_height_fit(base);
+        break;
+
+    case LV_ALIGN_OUT_LEFT_TOP:
+        x = -lv_obj_get_width_fit(obj);
+        y = 0;
+        break;
+
+    case LV_ALIGN_OUT_LEFT_MID:
+        x = -lv_obj_get_width_fit(obj);
+        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        break;
+
+    case LV_ALIGN_OUT_LEFT_BOTTOM:
+        x = -lv_obj_get_width_fit(obj);
+        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        break;
+
+    case LV_ALIGN_OUT_RIGHT_TOP:
+        x = lv_obj_get_width_fit(base);
+        y = 0;
+        break;
+
+    case LV_ALIGN_OUT_RIGHT_MID:
+        x = lv_obj_get_width_fit(base);
+        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        break;
+
+    case LV_ALIGN_OUT_RIGHT_BOTTOM:
+        x = lv_obj_get_width_fit(base);
+        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        break;
+    }
+
+    x += x_ofs;
+    y += y_ofs;
+
+    lv_obj_set_pos(obj, x, y);
 }
 
 
diff --git a/src/lv_misc/lv_anim.c b/src/lv_misc/lv_anim.c
index 37e62a9f7..4996eb8b1 100644
--- a/src/lv_misc/lv_anim.c
+++ b/src/lv_misc/lv_anim.c
@@ -314,7 +314,7 @@ lv_anim_value_t lv_anim_path_ease_in_out(const lv_anim_path_t * path, const lv_a
     else
         t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
 
-    int32_t step = _lv_bezier3(t, 0, 0, 1024, 1024);
+    int32_t step = _lv_bezier3(t, 0, 64, 1024 - 64, 1024);
 
     int32_t new_value;
     new_value = (int32_t)step * (a->end - a->start);
diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 3ef1bd9ae..c943aa674 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -25,7 +25,7 @@
  *********************/
 /*Add memory junk on alloc (0xaa) and free(0xbb) (just for testing purposes)*/
 #ifndef LV_MEM_ADD_JUNK
-    #define LV_MEM_ADD_JUNK 0
+    #define LV_MEM_ADD_JUNK 1
 #endif
 
 #ifndef LV_MEM_FULL_DEFRAG_CNT
diff --git a/src/lv_widgets/lv_btn.c b/src/lv_widgets/lv_btn.c
index b30744c3d..02c6a730b 100644
--- a/src/lv_widgets/lv_btn.c
+++ b/src/lv_widgets/lv_btn.c
@@ -71,6 +71,7 @@ lv_obj_t * lv_btn_create(lv_obj_t * parent, const lv_obj_t * copy)
         /*Set layout if the button is not a screen*/
         if(parent) {
             lv_obj_set_size(btn, LV_DPI, LV_DPI / 3);
+            lv_obj_clear_flag(btn, LV_OBJ_FLAG_SCROLLABLE);
         }
 
         lv_theme_apply(btn, LV_THEME_BTN);

From 7b4846424173ae5ead5e9af63aeede63e0f50276 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 13 Oct 2020 20:36:54 +0200
Subject: [PATCH 54/84] add lv_obj_get_child_by_id

---
 src/lv_core/lv_obj.c     | 18 ++++++++++++++++++
 src/lv_core/lv_obj.h     |  8 ++++++++
 src/lv_core/lv_obj_pos.c | 36 ++++++++++++++++++------------------
 3 files changed, 44 insertions(+), 18 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index aa6e48880..341e2a271 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1139,6 +1139,24 @@ lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child)
     return child ? _lv_ll_get_prev(&obj->child_ll, child) : _lv_ll_get_tail(&obj->child_ll);
 }
 
+/**
+ * Get the Nth child of a an object. 0th is the lastly created.
+ * @param obj pointer to an object whose children should be get
+ * @param id of a child
+ * @return the child or `NULL` if `id` was greater then the `number of children - 1`
+ */
+lv_obj_t * lv_obj_get_child_by_id(const lv_obj_t * obj, uint32_t id)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    uint32_t i;
+    for(i = 0; i < id; i++) {
+        child = lv_obj_get_child(obj, child);
+    }
+
+    return child;
+}
 /**
  * Count the children of an object (only children directly on 'obj')
  * @param obj pointer to an object
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 7e57432af..bb2c6b4c9 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -592,6 +592,14 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, const lv_obj_t * child);
  */
 lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child);
 
+/**
+ * Get the Nth child of a an object. 0th is the lastly created.
+ * @param obj pointer to an object whose children should be get
+ * @param id of a child
+ * @return the child or `NULL` if `id` was greater then the `number of children - 1`
+ */
+lv_obj_t * lv_obj_get_child_by_id(const lv_obj_t * obj, uint32_t id);
+
 /**
  * Count the children of an object (only children directly on 'obj')
  * @param obj pointer to an object
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index ad78c3d34..57ed5c4d5 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -315,57 +315,57 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 
     case LV_ALIGN_OUT_TOP_LEFT:
         x = 0;
-        y = -lv_obj_get_height_fit(obj);
+        y = -lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_OUT_TOP_MID:
-        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
-        y = -lv_obj_get_height_fit(obj);
+        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+        y = -lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_OUT_TOP_RIGHT:
-        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
-        y = -lv_obj_get_height_fit(obj);
+        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+        y = -lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_OUT_BOTTOM_LEFT:
         x = 0;
-        y = lv_obj_get_height_fit(base);
+        y = lv_obj_get_height(base);
         break;
 
     case LV_ALIGN_OUT_BOTTOM_MID:
-        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
-        y = lv_obj_get_height_fit(base);
+        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+        y = lv_obj_get_height(base);
         break;
 
     case LV_ALIGN_OUT_BOTTOM_RIGHT:
-        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
-        y = lv_obj_get_height_fit(base);
+        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+        y = lv_obj_get_height(base);
         break;
 
     case LV_ALIGN_OUT_LEFT_TOP:
-        x = -lv_obj_get_width_fit(obj);
+        x = -lv_obj_get_width(obj);
         y = 0;
         break;
 
     case LV_ALIGN_OUT_LEFT_MID:
-        x = -lv_obj_get_width_fit(obj);
-        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        x = -lv_obj_get_width(obj);
+        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
         break;
 
     case LV_ALIGN_OUT_LEFT_BOTTOM:
-        x = -lv_obj_get_width_fit(obj);
-        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        x = -lv_obj_get_width(obj);
+        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_OUT_RIGHT_TOP:
-        x = lv_obj_get_width_fit(base);
+        x = lv_obj_get_width(base);
         y = 0;
         break;
 
     case LV_ALIGN_OUT_RIGHT_MID:
-        x = lv_obj_get_width_fit(base);
-        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        x = lv_obj_get_width(base);
+        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
         break;
 
     case LV_ALIGN_OUT_RIGHT_BOTTOM:

From ae452cbc2259f18324b5b3af6abf6c573d153b1e Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 16 Oct 2020 13:00:53 +0200
Subject: [PATCH 55/84] add flexbox layout and percentage size

---
 src/lv_core/lv_flex.c         | 262 +++++++++++++++++++++++++++++++
 src/lv_core/lv_flex.h         |  64 ++++++++
 src/lv_core/lv_grid.c         | 284 +++++-----------------------------
 src/lv_core/lv_grid.h         |  85 +++-------
 src/lv_core/lv_obj.c          |  42 ++---
 src/lv_core/lv_obj.h          |   3 +
 src/lv_core/lv_obj_pos.c      | 112 ++++++++------
 src/lv_core/lv_obj_pos.h      |  22 +--
 src/lv_misc/lv_area.h         |  30 +++-
 src/lv_misc/lv_mem.c          |   2 +-
 src/lv_widgets/lv_checkbox.c  |   8 +-
 src/lv_widgets/lv_linemeter.h | 170 ++++++++++++++++++++
 src/lv_widgets/lv_roller.c    |   2 +-
 13 files changed, 688 insertions(+), 398 deletions(-)
 create mode 100644 src/lv_core/lv_flex.c
 create mode 100644 src/lv_core/lv_flex.h
 create mode 100644 src/lv_widgets/lv_linemeter.h

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
new file mode 100644
index 000000000..4e052b470
--- /dev/null
+++ b/src/lv_core/lv_flex.c
@@ -0,0 +1,262 @@
+/**
+ * @file lv_flex.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_flex.h"
+#include "lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_t main_dir, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size);
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_dir_t main_dir, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit);
+static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir)
+{
+    if(obj->flex_dir != flex_dir) return;
+
+    obj->flex_dir = flex_dir;
+    _lv_flex_refresh(obj);
+}
+
+void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
+{
+    lv_obj_set_pos(obj, place, place);
+}
+
+void _lv_flex_refresh(lv_obj_t * cont)
+{
+    if(cont->flex_dir == LV_FLEX_DIR_NONE) return;
+
+    lv_dir_t main_dir;
+    switch(cont->flex_dir) {
+    case LV_FLEX_DIR_ROW:
+        main_dir = LV_DIR_HOR;
+        break;
+    case LV_FLEX_DIR_ROW_WRAP:
+        main_dir = LV_DIR_HOR;
+        break;
+    case LV_FLEX_DIR_COLUMN:
+        main_dir = LV_DIR_VER;
+        break;
+    case LV_FLEX_DIR_COLUMN_WRAP:
+        main_dir = LV_DIR_VER;
+        break;
+    }
+
+    /*Count the grow units and free space*/
+    lv_coord_t max_main_size = (main_dir == LV_DIR_HOR ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
+    lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
+    lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
+
+    lv_coord_t * cross_pos = (main_dir == LV_DIR_HOR ? &abs_y : &abs_x);
+
+    lv_coord_t row_place = LV_FLEX_START;
+    lv_coord_t all_track_size = 0;
+    lv_coord_t gap = 0;
+    uint32_t row_cnt = 0;
+    lv_coord_t grow_unit;
+    lv_coord_t track_size;
+    lv_obj_t * track_first_item;
+    lv_obj_t * next_track_first_item;
+
+    if(row_place != LV_FLEX_START) {
+        track_first_item = _lv_ll_get_tail(&cont->child_ll);
+        while(track_first_item) {
+            /*Search the first item of the next row */
+            next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
+            all_track_size += track_size;
+            row_cnt++;
+            track_first_item = next_track_first_item;
+        }
+
+        lv_coord_t max_cross_size = (main_dir == LV_DIR_HOR ? lv_obj_get_height_fit(cont) : lv_obj_get_width_fit(cont));
+        place_content(row_place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
+    }
+
+    track_first_item = _lv_ll_get_tail(&cont->child_ll);
+    while(track_first_item) {
+        /*Search the first item of the next row */
+        next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
+
+        children_repos(cont, track_first_item, next_track_first_item, main_dir, abs_x, abs_y, track_size, grow_unit);
+
+        track_first_item = next_track_first_item;
+        *cross_pos += track_size + gap;
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_t main_dir, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
+{
+    lv_coord_t(*get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    lv_coord_t(*get_cross_size)(const lv_obj_t *) = (main_dir == LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+
+    bool wrap;
+    if(cont->flex_dir == LV_FLEX_DIR_ROW_WRAP || cont->flex_dir == LV_FLEX_DIR_COLUMN_WRAP) {
+        wrap = true;
+    } else {
+        wrap = false;
+    }
+
+    lv_coord_t grow_sum = 0;
+    lv_coord_t used_size = 0;
+    *track_cross_size = 0;
+    *grow_unit = 0;
+
+    lv_obj_t * item = item_start;
+    while(item) {
+        /*Ignore non-flex items*/
+        lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
+        if(LV_COORD_IS_FLEX(main_set) == false) {
+            item = _lv_ll_get_prev(&cont->child_ll, item);
+            continue;
+        }
+
+        lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
+        if(_LV_FLEX_GET_GROW(main_size)) {
+            grow_sum += _LV_FLEX_GET_GROW(main_size);
+        } else {
+            lv_coord_t item_size = get_main_size(item);
+            if(wrap && used_size + item_size > max_size) break;
+            used_size += item_size;
+        }
+
+        *track_cross_size = LV_MATH_MAX(get_cross_size(item), *track_cross_size);
+
+        item = _lv_ll_get_prev(&cont->child_ll, item);
+    }
+
+    *grow_unit = grow_sum ? (max_size - used_size) / grow_sum : 0;
+    if(*grow_unit < 0) *grow_unit = 0;
+
+    /*Have at least one item in a row*/
+    if(item && item == item_start) {
+        item = _lv_ll_get_prev(&cont->child_ll, item);
+        if(item) *track_cross_size = get_cross_size(item);
+    }
+
+    return item;
+}
+
+
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_dir_t main_dir, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
+{
+    lv_coord_t(*get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    void (*set_main_size)(lv_obj_t *, lv_coord_t) = (main_dir == LV_DIR_HOR ? lv_obj_set_width_margin : lv_obj_set_height_margin);
+    lv_coord_t(*get_cross_size)(const lv_obj_t *) = (main_dir ==  LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+
+    lv_coord_t main_pos = 0;
+    /*Reposition the children*/
+    lv_obj_t * item = item_first;   /*Just to use a shorter name*/
+    while(item != item_last) {
+
+        /*Ignore non-flex items*/
+        lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
+        if(LV_COORD_IS_FLEX(main_set) == false) {
+            item = _lv_ll_get_prev(&cont->child_ll, item);
+            continue;
+        }
+
+        lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
+        if(_LV_FLEX_GET_GROW(main_size)) {
+            lv_coord_t s =  _LV_FLEX_GET_GROW(main_size) * grow_unit;
+            set_main_size(item, s);
+        }
+
+        lv_coord_t cross_pos = 0;
+        lv_coord_t cross_set = (main_dir == LV_DIR_HOR ? item->y_set : item->x_set);
+        switch(cross_set) {
+        case LV_FLEX_CENTER:
+            cross_pos = (track_size - get_cross_size(item)) / 2;
+            break;
+        case LV_FLEX_END:
+            cross_pos = track_size - get_cross_size(item);
+            break;
+        }
+
+        lv_coord_t diff_x;
+        lv_coord_t diff_y;
+        if(main_dir == LV_DIR_HOR) {
+            diff_x = abs_x + main_pos - item->coords.x1;
+            diff_y = abs_y + cross_pos - item->coords.y1;
+        } else {
+            diff_x = abs_x + cross_pos - item->coords.x1;
+            diff_y = abs_y + main_pos - item->coords.y1;
+        }
+
+        if(diff_x || diff_y) {
+            item->coords.x1 += diff_x;
+            item->coords.x2 += diff_x;
+            item->coords.y1 += diff_y;
+            item->coords.y2 += diff_y;
+            _lv_obj_move_children_by(item, diff_x, diff_y);
+        }
+        main_pos += get_main_size(item);
+        item = _lv_ll_get_prev(&cont->child_ll, item);
+    }
+}
+
+
+static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap)
+{
+    if(track_cnt <= 1) {
+        switch(place) {
+            case LV_FLEX_SPACE_BETWEEN:
+            case LV_FLEX_SPACE_AROUND:
+            case LV_FLEX_SPACE_EVENLY:
+                place = LV_FLEX_CENTER;
+                break;
+        }
+    }
+
+    switch(place) {
+    case LV_FLEX_CENTER:
+        *start_pos += (max_size - track_size) / 2;
+        break;
+    case LV_FLEX_END:
+        *start_pos += max_size - track_size;
+        break;
+    case LV_FLEX_SPACE_BETWEEN:
+       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt - 1);
+       break;
+   case LV_FLEX_SPACE_AROUND:
+       *gap += (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt);
+       *start_pos += *gap / 2;
+       break;
+   case LV_FLEX_SPACE_EVENLY:
+       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt + 1);
+       *start_pos += *gap;
+       break;
+   default:
+       *gap = 0;
+    }
+}
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
new file mode 100644
index 000000000..07ab06da4
--- /dev/null
+++ b/src/lv_core/lv_flex.h
@@ -0,0 +1,64 @@
+/**
+ * @file lv_flex.h
+ *
+ */
+
+#ifndef LV_FLEX_H
+#define LV_FLEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_grid.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/** Can be set as width or height (on main axis) to grow the object in order fill the free space*/
+#define LV_FLEX_GROW(grow)    (_LV_COORD_FELX(grow))
+
+#define _LV_FLEX_GET_GROW(v) (LV_COORD_IS_FLEX(v) ? LV_COORD_GET_FLEX(v) : 0)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_FLEX_START = _LV_COORD_FELX(0),
+    LV_FLEX_END = _LV_COORD_FELX(1),
+    LV_FLEX_CENTER = _LV_COORD_FELX(2),
+    LV_FLEX_SPACE_EVENLY = _LV_COORD_FELX(3),
+    LV_FLEX_SPACE_AROUND = _LV_COORD_FELX(4),
+    LV_FLEX_SPACE_BETWEEN = _LV_COORD_FELX(5),
+}lv_flex_place_t;
+
+typedef enum {
+    LV_FLEX_DIR_NONE,
+    LV_FLEX_DIR_ROW,
+    LV_FLEX_DIR_ROW_WRAP,
+    LV_FLEX_DIR_COLUMN,
+    LV_FLEX_DIR_COLUMN_WRAP,
+} lv_flex_dir_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir);
+void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
+void _lv_flex_refresh(lv_obj_t * cont);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_FLEX_H*/
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index dc7623cef..c4ed0a59b 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -26,10 +26,8 @@ typedef struct {
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
-static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
-static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
-static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
+static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint);
 static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array);
 static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
@@ -99,24 +97,17 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
 void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
 {
     if(cont->grid == NULL) return;
+    if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) return;
+    if(cont->grid->col_dsc_len == 0 || cont->grid->row_dsc_len == 0) return;
+
     if(lv_obj_get_child(cont, NULL) == NULL) {
         _lv_memset_00(calc_out, sizeof(_lv_grid_calc_t));
         return;
     }
 //    printf("calc: %d, %d\n", obj->grid->col_dsc_len, obj->grid->row_dsc_len);
 
-    if(cont->grid->col_dsc && cont->grid->row_dsc) {
-        calc_explicit_rows(cont, calc_out);
-        calc_explicit_cols(cont, calc_out);
-    }
-    else if(cont->grid->col_dsc && !cont->grid->row_dsc) {
-        calc_explicit_cols(cont, calc_out);
-        calc_implicit_rows(cont, calc_out);
-    }
-    else if(!cont->grid->col_dsc && cont->grid->row_dsc) {
-        calc_explicit_rows(cont, calc_out);
-        calc_implicit_cols(cont, calc_out);
-    }
+    calc_rows(cont, calc_out);
+    calc_cols(cont, calc_out);
 
     bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
@@ -153,7 +144,7 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
 
     uint32_t i;
     for(i = 0; i < obj->grid->col_dsc_len; i++) {
-        if(_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
+        if(LV_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
     }
 
     return false;
@@ -171,43 +162,12 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
 
     uint32_t i;
     for(i = 0; i < obj->grid->row_dsc_len; i++) {
-        if(_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
+        if(LV_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
     }
 
     return false;
 }
 
-/**
- * Check if the object's grid columns are "fill" type
- * @param obj pointer to an object
- * @return true: fill type; false: not fill type
- */
-bool _lv_grid_has_fill_col(struct _lv_obj_t * obj)
-{
-    if(obj->grid == NULL) return false;
-    if(obj->grid->col_dsc == NULL)  return false;
-    if(obj->grid->col_dsc_len != 1)  return false;
-    if(_GRID_IS_FILL(obj->grid->col_dsc[0]) == false) return false;
-
-    return true;
-}
-
-/**
- * Check if the object's grid rows are "fill" type
- * @param obj pointer to an object
- * @return true: fill type; false: not fill type
- */
-bool _lv_grid_has_fill_row(struct _lv_obj_t * obj)
-{
-    if(obj->grid == NULL) return false;
-    if(obj->grid->row_dsc == NULL)  return false;
-    if(obj->grid->row_dsc_len != 1)  return false;
-    if(_GRID_IS_FILL(obj->grid->row_dsc[0]) == false) return false;
-
-    return true;
-}
-
-
 /**
  * Refresh the all grid item on a container
  * @param cont pointer to a grid container object
@@ -232,7 +192,7 @@ void _lv_grid_full_refresh(lv_obj_t * cont)
 
     lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
     while(item) {
-        if(_GRID_IS_CELL(item->x_set) && _GRID_IS_CELL(item->y_set)) {
+        if(LV_COORD_IS_GRID(item->x_set) && LV_COORD_IS_GRID(item->y_set)) {
             item_repos(cont, item, &calc, &hint);
         }
         item = lv_obj_get_child_back(cont, item);
@@ -266,80 +226,46 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
  *   STATIC FUNCTIONS
  **********************/
 
-static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
+static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
     const lv_grid_t * grid = cont->grid;
     uint32_t i;
 
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
-    bool fill = false;
-    bool all = false;
-    if(grid->col_dsc_len == 1 && _GRID_IS_FILL(grid->col_dsc[0])) fill = true;
-    if(grid->col_dsc_len == 1 && _GRID_IS_REPEAT(grid->col_dsc[0])) all = true;
 
-    if(fill) {
-        lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
-        /* Get number of tracks fitting to the content
-         * Add the gap to cont_w because here is no gap after the last track so compensate it*/
-        calc->col_num = (cont_w + grid->col_gap) / (fill_w + grid->col_gap);
-    }
-    if(all) {
-        calc->col_num = lv_obj_count_children(cont);
-    }
-    else {
-        calc->col_num = grid->col_dsc_len;
-    }
+    calc->col_num = grid->col_dsc_len;
     calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
     calc->w = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
 
-    /*If filled, it's simple: every track has fill size*/
-    if(fill) {
-        lv_coord_t fill_w = _GRID_GET_FILL(grid->col_dsc[0]);
-        for(i = 0; i < calc->col_num; i++) {
-            calc->w[i] = fill_w;
+    uint32_t col_fr_cnt = 0;
+    lv_coord_t grid_w = 0;
+    bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
+
+    for(i = 0; i < calc->col_num; i++) {
+        lv_coord_t x = grid->col_dsc[i];
+        if(LV_GRID_IS_FR(x)) col_fr_cnt += LV_GRID_GET_FR(x);
+        else {
+            calc->w[i] = x;
+            grid_w += x;
         }
     }
-    /*If repeated, it's simple: every track has the "repeat size"*/
-    else if(all) {
-        lv_coord_t rep_w;
-        if(grid->col_dsc[0] == LV_GRID_REPEAT_FIT) rep_w = lv_obj_get_width_fit(cont);
-        else rep_w = _GRID_GET_REPEAT(grid->col_dsc[0]);
 
-        for(i = 0; i < calc->col_num; i++) {
-            calc->w[i] = rep_w;
-        }
-    }
-    else {
-        uint32_t col_fr_cnt = 0;
-        lv_coord_t grid_w = 0;
-        bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
+    cont_w -= grid->col_gap * (calc->col_num - 1);
+    lv_coord_t free_w = cont_w - grid_w;
 
-        for(i = 0; i < calc->col_num; i++) {
-            lv_coord_t x = grid->col_dsc[i];
-            if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
+    for(i = 0; i < calc->col_num; i++) {
+        lv_coord_t x = grid->col_dsc[i];
+        if(LV_GRID_IS_FR(x)) {
+            if(auto_w) calc->w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
             else {
-                calc->w[i] = x;
-                grid_w += x;
-            }
-        }
-
-        cont_w -= grid->col_gap * (calc->col_num - 1);
-        lv_coord_t free_w = cont_w - grid_w;
-
-        for(i = 0; i < calc->col_num; i++) {
-            lv_coord_t x = grid->col_dsc[i];
-            if(_GRID_IS_FR(x)) {
-                if(auto_w) calc->w[i] = 0;   /*Fr is considered zero if the cont has auto width*/
-                else {
-                    lv_coord_t f = _GRID_GET_FR(x);
-                    calc->w[i] = (free_w * f) / col_fr_cnt;
-                }
+                lv_coord_t f = LV_GRID_GET_FR(x);
+                calc->w[i] = (free_w * f) / col_fr_cnt;
             }
         }
     }
 }
 
-static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
+static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
     const lv_grid_t * grid = cont->grid;
     uint32_t i;
@@ -356,7 +282,7 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     for(i = 0; i < grid->row_dsc_len; i++) {
         lv_coord_t x = grid->row_dsc[i];
-        if(_GRID_IS_FR(x)) row_fr_cnt += _GRID_GET_FR(x);
+        if(LV_GRID_IS_FR(x)) row_fr_cnt += LV_GRID_GET_FR(x);
         else {
             calc->h[i] = x;
             grid_h += x;
@@ -368,86 +294,16 @@ static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
     for(i = 0; i < grid->row_dsc_len; i++) {
         lv_coord_t x = grid->row_dsc[i];
-        if(_GRID_IS_FR(x)) {
+        if(LV_GRID_IS_FR(x)) {
             if(auto_h) calc->h[i] = 0;   /*Fr is considered zero if the obj has auto height*/
             else {
-                lv_coord_t f = _GRID_GET_FR(x);
+                lv_coord_t f = LV_GRID_GET_FR(x);
                 calc->h[i] = (free_h * f) / row_fr_cnt;
             }
         }
     }
 }
 
-
-static void calc_implicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
-{
-    const lv_grid_t * grid = cont->grid;
-
-    uint32_t child_cnt = lv_obj_count_children(cont);
-
-    calc->col_num = ((child_cnt + grid->row_dsc_len - 1) / grid->row_dsc_len); /*+ grid->row_dsc_len - 1 to round up*/
-    calc->w  = _lv_mem_buf_get(sizeof(lv_coord_t) * (calc->col_num + 1));   /*+1 to allow some limit checks later*/
-    calc->x = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_num);
-
-    lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
-    uint32_t row_i = 0;
-    uint32_t col_i = 0;
-    calc->w[0] = 0;
-    while(child) {
-        if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-            lv_coord_t w;
-            if(_GRID_GET_CELL_FLAG(child->x_set) == LV_GRID_STRETCH) {
-                lv_obj_scroll_to_x(child, 0, LV_ANIM_OFF);
-                _lv_obj_calc_auto_size(child,  &w, NULL);
-            }
-            else w = lv_obj_get_width(child);
-            calc->w[col_i] = LV_MATH_MAX(calc->w[col_i], w);
-            row_i++;
-            if(row_i == grid->row_dsc_len) {
-                row_i = 0;
-                col_i++;
-                calc->w[col_i] = 0;
-            }
-        }
-        child = lv_obj_get_child_back(cont, child);
-    }
-}
-
-
-static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
-{
-
-    const lv_grid_t * grid = cont->grid;
-    uint32_t child_cnt = lv_obj_count_children(cont);
-    calc->row_num  = ((child_cnt + calc->col_num - 1) / calc->col_num); /*+ grid->col_dsc_len - 1 to round up*/
-    calc->h = _lv_mem_buf_get(sizeof(lv_coord_t) * (calc->row_num + 1));   /*+1 to allow some limit checks later*/
-    calc->y = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_num);
-
-    lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
-    uint32_t col_i = 0;
-    uint32_t row_i = 0;
-    calc->h[0] = 0;
-    while(child) {
-        if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-            lv_coord_t h;
-            if(_GRID_GET_CELL_FLAG(child->y_set) == LV_GRID_STRETCH) {
-                lv_obj_scroll_to_y(child, 0, LV_ANIM_OFF);
-                _lv_obj_calc_auto_size(child,  NULL, &h);
-            }
-            else h = lv_obj_get_height(child);
-            calc->h[row_i] = LV_MATH_MAX(calc->h[row_i], h);
-            col_i++;
-            if(col_i == calc->col_num) {
-                col_i = 0;
-                row_i++;
-                calc->h[row_i] = 0;
-            }
-        }
-        child = lv_obj_get_child_back(cont, child);
-    }
-}
-
-
 /**
  * Reposition a grid item in its cell
  * @param cont a grid container object
@@ -460,60 +316,10 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
 {
     if(_lv_obj_is_grid_item(item) == false) return;
 
-    uint32_t col_pos;
-    uint32_t col_span;
-    uint32_t row_pos;
-    uint32_t row_span;
-
-    if(cont->grid->row_dsc && cont->grid->col_dsc) {
-        col_pos = _GRID_GET_CELL_POS(item->x_set);
-        col_span = _GRID_GET_CELL_SPAN(item->x_set);
-        row_pos = _GRID_GET_CELL_POS(item->y_set);
-        row_span = _GRID_GET_CELL_SPAN(item->y_set);
-    } else {
-        col_span = 1;
-        row_span = 1;
-
-        if(hint) {
-            col_pos = hint->col;
-            row_pos = hint->row;
-
-            if(cont->grid->row_dsc == NULL) {
-                hint->col++;
-                if(hint->col >= calc->col_num) {
-                    hint->col = 0;
-                    hint->row++;
-                }
-            } else {
-                hint->row++;
-                if(hint->row >= calc->row_num) {
-                    hint->row = 0;
-                    hint->col++;
-                }
-            }
-        }
-        /*No hint -> find the child ID and calculate its col and row position */
-        else {
-            uint32_t child_id = 0;
-            lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
-
-            while(child) {
-                if(child == item) break;
-                if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
-                    child_id++;
-                }
-                child = lv_obj_get_child_back(cont, child);
-            }
-
-            if(cont->grid->row_dsc == NULL) {
-                col_pos = child_id % calc->col_num;
-                row_pos = child_id / calc->col_num;
-            } else {
-                col_pos = child_id / calc->row_num;
-                row_pos = child_id % calc->row_num;
-            }
-        }
-    }
+    uint32_t col_pos = LV_GRID_GET_CELL_POS(item->x_set);
+    uint32_t col_span = LV_GRID_GET_CELL_SPAN(item->x_set);
+    uint32_t row_pos = LV_GRID_GET_CELL_POS(item->y_set);
+    uint32_t row_span = LV_GRID_GET_CELL_SPAN(item->y_set);
 
     lv_coord_t col_x1 = calc->x[col_pos];
     lv_coord_t col_x2 = calc->x[col_pos + col_span - 1] + calc->w[col_pos + col_span - 1];
@@ -523,8 +329,8 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
     lv_coord_t row_y2 = calc->y[row_pos + row_span - 1] + calc->h[row_pos + row_span - 1];
     lv_coord_t row_h = row_y2 - row_y1;
 
-    uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
-    uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
+    uint8_t x_flag = LV_GRID_GET_CELL_PLACE(item->x_set);
+    uint8_t y_flag = LV_GRID_GET_CELL_PLACE(item->y_set);
 
     lv_coord_t x;
     lv_coord_t y;
@@ -575,15 +381,6 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
         lv_obj_invalidate(item);
         item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
 
-        /* If a children is a grid container and has an FR field it also needs to be updated
-         * because the FR cell size will change with child size change. */
-        lv_obj_t * child = lv_obj_get_child(item, NULL);
-        while(child) {
-            if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
-                _lv_grid_full_refresh(child);
-            }
-            child = lv_obj_get_child(item, child);
-        }
     }
     bool moved = true;
     if(hint) {
@@ -613,7 +410,6 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
     if(auto_size) {
         pos_array[0] = 0;
     } else {
-
         /*With spaced placements gap will be calculated from the remaining space*/
         if(place == LV_GRID_SPACE_AROUND || place == LV_GRID_SPACE_BETWEEN || place == LV_GRID_SPACE_EVENLY) {
             gap = 0;
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index e45749f9d..4b1b6cc5a 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -19,6 +19,15 @@ extern "C" {
  *      DEFINES
  *********************/
 
+/**
+ * Some helper defines
+ * */
+#define _LV_GRID_CELL_SHIFT        4
+#define _LV_GRID_CELL_POS_MASK     ((1 << _LV_GRID_CELL_SHIFT) - 1)
+#define _LV_GRID_CELL_SPAN_MASK    (_LV_GRID_CELL_POS_MASK << _LV_GRID_CELL_SHIFT)
+#define _LV_GRID_CELL_FLAG_MASK    (_LV_GRID_CELL_POS_MASK << (2 * _LV_GRID_CELL_SHIFT))
+#define _LV_GRID_CELL_PLACE(b)      ((b) << (_LV_GRID_CELL_SHIFT * 2))
+
 #define LV_GRID_START               0
 #define LV_GRID_CENTER              1
 #define LV_GRID_END                 2
@@ -27,61 +36,18 @@ extern "C" {
 #define LV_GRID_SPACE_AROUND        5
 #define LV_GRID_SPACE_BETWEEN       6
 
-/**
- * Some helper defines
- * */
-#define _GRID_IS_CELL(c)        ((c) >= LV_COORD_MAX ? true : false)
-#define _GRID_CELL_SHIFT        5
-#define _GRID_CELL_MAX          ((1 << _GRID_CELL_SHIFT) - 1)
-#define _GRID_CELL_POS_MASK     ((1 << _GRID_CELL_SHIFT) - 1)
-#define _GRID_CELL_SPAN_MASK    (_GRID_CELL_POS_MASK << _GRID_CELL_SHIFT)
-#define _GRID_CELL_FLAG_MASK    (_GRID_CELL_POS_MASK << (2 * _GRID_CELL_SHIFT))
-#define _GRID_CELL_FLAG(b)      ((b) << (_GRID_CELL_SHIFT * 2))
-#define _GRID_CELL_AUTO         _GRID_CELL_MAX
-#define _GRID_GET_CELL_POS(c)   ((c) & _GRID_CELL_POS_MASK)
-#define _GRID_GET_CELL_SPAN(c)  (((c) & _GRID_CELL_SPAN_MASK) >> _GRID_CELL_SHIFT)
-#define _GRID_GET_CELL_FLAG(c)  ((c) >> (_GRID_CELL_SHIFT * 2) & 0x3)
+#define LV_GRID_CELL_START(pos, span)   (_LV_COORD_GRID((pos) | ((span) << (_LV_GRID_CELL_SHIFT)) | _LV_GRID_CELL_PLACE(LV_GRID_START)))
+#define LV_GRID_CELL_END(pos, span)     (_LV_COORD_GRID((pos) | ((span) << (_LV_GRID_CELL_SHIFT)) | _LV_GRID_CELL_PLACE(LV_GRID_END)))
+#define LV_GRID_CELL_CENTER(pos, span)  (_LV_COORD_GRID((pos) | ((span) << (_LV_GRID_CELL_SHIFT)) | _LV_GRID_CELL_PLACE(LV_GRID_CENTER)))
+#define LV_GRID_CELL_STRETCH(pos, span) (_LV_COORD_GRID((pos) | ((span) << (_LV_GRID_CELL_SHIFT)) | _LV_GRID_CELL_PLACE(LV_GRID_STRETCH)))
 
-#define _GRID_CELL_SIZE_PX    0     /* The cell size is set in pixels*/
-#define _GRID_CELL_SIZE_FR    1     /* The cell size is set in free units*/
+#define LV_GRID_GET_CELL_POS(c)   ((c) & _LV_GRID_CELL_POS_MASK)
+#define LV_GRID_GET_CELL_SPAN(c)  (((c) & _LV_GRID_CELL_SPAN_MASK) >> _LV_GRID_CELL_SHIFT)
+#define LV_GRID_GET_CELL_PLACE(c)  ((c) >> (_LV_GRID_CELL_SHIFT * 2) & 0x7)
 
-#define _GRID_FR_MAX            256
-#define _GRID_FILL_MAX          2048
-#define _GRID_REPEAT_MAX           2048
-#define _GRID_FR_START        (LV_COORD_MAX)
-#define _GRID_FILL_START      (_GRID_FR_START + _GRID_FR_MAX)
-#define _GRID_REPEAT_START    (_GRID_FILL_START + _GRID_FILL_MAX)
-
-#define LV_GRID_FR(x)     (_GRID_FR_START + (x))
-#define LV_GRID_FILL(x)   (_GRID_FILL_START + (x))
-#define LV_GRID_REPEAT(x) (_GRID_REPEAT_START + (x))
-#define LV_GRID_REPEAT_FIT (_GRID_REPEAT_START + _GRID_REPEAT_MAX - 1)
-
-#define _GRID_IS_PX(x)      ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
-#define _GRID_IS_FR(x)      ((x) > _GRID_FR_START && (x) <  _GRID_FILL_START ? true : false)
-#define _GRID_IS_FILL(x)    ((x) > _GRID_FILL_START && (x) < _GRID_REPEAT_START ? true : false)
-#define _GRID_IS_REPEAT(x)  ((x) > _GRID_REPEAT_START  ? true : false)
-#define _GRID_IS_AUTO(x)    (x == LV_GRID_AUTO ? true : false)
-#define _GRID_GET_FR(x)     ((x) - LV_COORD_MAX)
-#define _GRID_GET_FILL(x)     ((x) - _GRID_FILL_START)
-#define _GRID_GET_REPEAT(x)     ((x) - _GRID_REPEAT_START)
-
-
-/**
- * Define a grid cell with position and span.
- * Can be used like `lv_obj_set_pos(btn, LV_GRID_CELL(3,2), LV_GRID_CELL(2,1))`
- */
-#define LV_GRID_CELL_START(pos, span)   ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_START))
-#define LV_GRID_CELL_END(pos, span)     ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_END))
-#define LV_GRID_CELL_CENTER(pos, span)  ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_CENTER))
-#define LV_GRID_CELL_STRETCH(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_STRETCH))
-/**
- * Special LV_GRID_CELL position to flow the object automatically.
- * Both X (column) and Y (row) value needs to be AUTO or explicitly specified*/
-#define LV_GRID_AUTO_START      LV_GRID_CELL_START(_GRID_CELL_AUTO, 0)
-#define LV_GRID_AUTO_END        LV_GRID_CELL_END(_GRID_CELL_AUTO, 0)
-#define LV_GRID_AUTO_CENTER     LV_GRID_CELL_CENTER(_GRID_CELL_AUTO, 0)
-#define LV_GRID_AUTO_STRETCH    LV_GRID_CELL_STRETCH(_GRID_CELL_AUTO, 0)
+#define LV_GRID_FR(x)          (_LV_COORD_GRID(x))
+#define LV_GRID_IS_FR(x)       (LV_COORD_IS_GRID(x))
+#define LV_GRID_GET_FR(x)      (LV_COORD_GET_GRID(x))
 
 /**********************
  *      TYPEDEFS
@@ -154,19 +120,6 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
 
 
-/**
- * Check if the object's grid columns are "fill" type
- * @param obj pointer to an object
- * @return true: fill type; false: not fill type
- */
-bool _lv_grid_has_fill_col(struct _lv_obj_t * obj);
-/**
- * Check if the object's grid rows are "fill" type
- * @param obj pointer to an object
- * @return true: fill type; false: not fill type
- */
-bool _lv_grid_has_fill_row(struct _lv_obj_t * obj);
-
 void _lv_grid_full_refresh(lv_obj_t * cont);
 
 void lv_grid_item_refr_pos(lv_obj_t * item);
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 341e2a271..414d2f946 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1906,19 +1906,31 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {
-            bool col_fr =   _lv_grid_has_fr_col(obj);
-            bool col_fill = _lv_grid_has_fill_col(obj);
-            bool row_fr =   _lv_grid_has_fr_row(obj);
-            bool row_fill = _lv_grid_has_fill_row(obj);
 
-            if(param == NULL ||
-              (lv_area_get_width(param) != lv_obj_get_width(obj) && (col_fr || col_fill)) ||
-              (lv_area_get_height(param) != lv_obj_get_height(obj) && (row_fr || row_fill)))
-        {
-            _lv_grid_full_refresh(obj);
+        bool w_new = true;
+        bool h_new = true;
+        if(param) {
+            if(lv_area_get_width(param) == lv_obj_get_width(obj)) w_new = false;
+            if(lv_area_get_height(param) == lv_obj_get_height(obj)) h_new = false;
+        }
+
+        if(w_new || h_new) {
+            lv_coord_t cont_w = lv_obj_get_width_fit(obj);
+            lv_coord_t cont_h = lv_obj_get_height_fit(obj);
+            lv_obj_t * child;
+            _LV_LL_READ(obj->child_ll, child) {
+                if(LV_COORD_IS_PCT(child->w_set) && w_new) lv_obj_set_width(child, (LV_COORD_GET_PCT(child->w_set) * cont_w) / 100);
+                if(LV_COORD_IS_PCT(child->h_set) && h_new) lv_obj_set_height(child, (LV_COORD_GET_PCT(child->h_set) * cont_h) / 100);
+            }
+            if(obj->grid) _lv_grid_full_refresh(obj);
+            if(obj->flex_dir) _lv_flex_refresh(obj);
         }
     }
     else if(sign == LV_SIGNAL_CHILD_CHG) {
+        if(param == NULL || _lv_obj_is_flex_item(param)) {
+            _lv_flex_refresh(obj);
+        }
+
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
@@ -1933,16 +1945,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
             }
         }
 
-        /* If the parent has an implicit grid in a direction and this object (whose child has changed)
-         * is stretched in that direction then the grid of the parent might have changed because
-         * the track size of implicit grids with stretched cells is calculated from the children bounding box.*/
-        lv_obj_t * par = lv_obj_get_parent(obj);
-        if(par && _lv_obj_is_grid_item(obj) &&
-                ((par->grid->col_dsc == NULL && _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) ||
-                (par->grid->row_dsc == NULL && _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH))) {
-            _lv_grid_full_refresh(par);
-        }
-
     }
     else if(sign == LV_SIGNAL_SCROLL) {
         res = lv_event_send(obj, LV_EVENT_SCROLL, NULL);
@@ -1965,7 +1967,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         /*Reposition non grid objects on by one*/
         lv_obj_t * child = lv_obj_get_child(obj, NULL);
         while(child) {
-            if(!_GRID_IS_CELL(child->x_set) || !_GRID_IS_CELL(child->y_set)) {
+            if(!LV_COORD_IS_GRID(child->x_set) || !LV_COORD_IS_GRID(child->y_set)) {
                 lv_obj_set_pos(child, child->x_set, child->y_set);
             }
             child = lv_obj_get_child(obj, child);
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index bb2c6b4c9..c43c48b4c 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -19,6 +19,7 @@ extern "C" {
 #include <stdbool.h>
 #include "lv_style.h"
 #include "lv_grid.h"
+#include "lv_flex.h"
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_color.h"
@@ -255,6 +256,8 @@ typedef struct _lv_obj_t {
 
     const lv_grid_t * grid;
 
+    uint8_t flex_dir;
+
 } lv_obj_t;
 
 enum {
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 57ed5c4d5..54be84cf5 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -54,36 +54,30 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->y_set = y;
 
     bool gi = _lv_obj_is_grid_item(obj);
+    bool fi = _lv_obj_is_flex_item(obj);
 
     /*For consistency set the size to stretched if the objects is stretched on the grid*/
     if(gi) {
-        if(_GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
-        if(_GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
+        if(LV_GRID_GET_CELL_PLACE(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
+        if(LV_GRID_GET_CELL_PLACE(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
     }
 
-    /*If not grid item but has grid position set the position to 0*/
+    /*If not grid or flex item but has grid or flex position set the position to 0*/
     if(!gi) {
-        if(_GRID_IS_CELL(x)) {
-            x = 0;
-        }
-        if(_GRID_IS_CELL(y)) {
-            y = 0;
-        }
+        if(LV_COORD_IS_GRID(x)) x = 0;
+        if(LV_COORD_IS_GRID(y)) y = 0;
+    }
+
+    if(!fi) {
+        if(LV_COORD_IS_FLEX(x)) x = 0;
+        if(LV_COORD_IS_FLEX(y)) y = 0;
     }
 
     /*If the object is on a grid item let the grid to position it. */
     if(gi) {
-        lv_obj_t * cont = lv_obj_get_parent(obj);
-
-        /*If the item was moved on an implicit grid the whole grid can change so refresh the full grid.*/
-        if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL)
-        {
-            _lv_grid_full_refresh(cont);
-        }
-        /*On explicit grids the grid itself doesn't depend on the items, so just position the item*/
-        else {
-            lv_grid_item_refr_pos(obj);
-        }
+        lv_grid_item_refr_pos(obj);
+    } else if(fi) {
+        _lv_flex_refresh(lv_obj_get_parent(obj));
     } else {
         _lv_obj_move_to(obj, x, y, true);
     }
@@ -124,12 +118,13 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     bool gi = _lv_obj_is_grid_item(obj);
+    bool fi = _lv_obj_is_flex_item(obj);
     bool x_stretch = false;
     bool y_stretch = false;
 
     if(gi) {
-        x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
-        y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
+        x_stretch = LV_GRID_GET_CELL_PLACE(obj->x_set) == LV_GRID_STRETCH ? true : false;
+        y_stretch = LV_GRID_GET_CELL_PLACE(obj->y_set) == LV_GRID_STRETCH ? true : false;
         if(x_stretch) w = LV_SIZE_STRETCH;
         if(y_stretch) h = LV_SIZE_STRETCH;
     }
@@ -137,7 +132,7 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     obj->w_set = w;
     obj->h_set = h;
 
-    /*If both stretched it was already managed by the grid*/
+    /*If both stretched the size is managed by the grid*/
     if(x_stretch && y_stretch) return;
 
     if(x_stretch) w = lv_obj_get_width(obj);
@@ -151,20 +146,20 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     if(x_auto) lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
     if(y_auto) lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
 
-    lv_coord_t auto_w;
-    lv_coord_t auto_h;
-    if(x_auto && y_auto) {
-        _lv_obj_calc_auto_size(obj, &auto_w, &auto_h);
-        w = auto_w;
-        h = auto_h;
-    }
-    else if(x_auto) {
-        _lv_obj_calc_auto_size(obj, &auto_w, NULL);
-        w = auto_w;
-    }
-    else if(y_auto) {
-        _lv_obj_calc_auto_size(obj, NULL, &auto_h);
-        h = auto_h;
+    if(x_auto && y_auto) _lv_obj_calc_auto_size(obj, &w, &h);
+    else if(x_auto) _lv_obj_calc_auto_size(obj, &w, NULL);
+    else if(y_auto) _lv_obj_calc_auto_size(obj, NULL, &h);
+
+    /*Calculate the required auto sizes*/
+    bool pct_w = LV_COORD_IS_PCT(obj->w_set) ? true : false;
+    bool pct_h = LV_COORD_IS_PCT(obj->h_set) ? true : false;
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent) {
+        lv_coord_t cont_w = lv_obj_get_width_fit(parent);
+        lv_coord_t cont_h = lv_obj_get_height_fit(parent);
+        if(pct_w) w = (LV_COORD_GET_PCT(obj->w_set) * cont_w) / 100;
+        if(pct_h) h = (LV_COORD_GET_PCT(obj->h_set) * cont_h) / 100;
     }
 
     refr_size(obj, w, h);
@@ -523,7 +518,7 @@ lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj)
  * @param obj pointer to an object
  * @return the height including the margins
  */
-lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj)
+lv_coord_t lv_obj_get_height_margin(const lv_obj_t * obj)
 {
     lv_style_int_t mtop = lv_obj_get_style_margin_top(obj, LV_OBJ_PART_MAIN);
     lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(obj, LV_OBJ_PART_MAIN);
@@ -537,7 +532,7 @@ lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj)
  * @param obj pointer to an object
  * @return the height including the margins
  */
-lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
+lv_coord_t lv_obj_get_width_margin(const lv_obj_t * obj)
 {
     lv_style_int_t mleft = lv_obj_get_style_margin_left(obj, LV_OBJ_PART_MAIN);
     lv_style_int_t mright = lv_obj_get_style_margin_right(obj, LV_OBJ_PART_MAIN);
@@ -550,7 +545,7 @@ lv_coord_t lv_obj_get_width_margin(lv_obj_t * obj)
  * @param obj pointer to an objects
  * @return the width of the virtually drawn content
  */
-lv_coord_t _lv_obj_get_self_width(lv_obj_t * obj)
+lv_coord_t _lv_obj_get_self_width(struct _lv_obj_t * obj)
 {
     lv_point_t p = {0, LV_COORD_MIN};
     lv_signal_send((lv_obj_t * )obj, LV_SIGNAL_GET_SELF_SIZE, &p);
@@ -562,7 +557,7 @@ lv_coord_t _lv_obj_get_self_width(lv_obj_t * obj)
  * @param obj pointer to an objects
  * @return the width of the virtually drawn content
  */
-lv_coord_t _lv_obj_get_self_height(lv_obj_t * obj)
+lv_coord_t _lv_obj_get_self_height(struct _lv_obj_t * obj)
 {
     lv_point_t p = {LV_COORD_MIN, 0};
     lv_signal_send((lv_obj_t * )obj, LV_SIGNAL_GET_SELF_SIZE, &p);
@@ -574,7 +569,7 @@ lv_coord_t _lv_obj_get_self_height(lv_obj_t * obj)
  * @param obj pointer to an object
  * @return false: nothing happened; true: refresh happened
  */
-bool _lv_obj_handle_self_size_chg(lv_obj_t * obj)
+bool _lv_obj_handle_self_size_chg(struct _lv_obj_t * obj)
 {
     if(obj->w_set != LV_SIZE_AUTO && obj->h_set == LV_SIZE_AUTO) return false;
 
@@ -650,7 +645,7 @@ void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_par
         y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
     } else {
         /*If no parent then it's screen but screen can't be on a grid*/
-        if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
+        if(LV_COORD_IS_GRID(obj->x_set) || LV_COORD_IS_GRID(obj->x_set)) {
             obj->x_set = 0;
             obj->y_set = 0;
             x = 0;
@@ -722,10 +717,30 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
     lv_obj_t * cont = lv_obj_get_parent(obj);
     if(cont == NULL) return false;
     if(cont->grid == NULL) return false;
-    if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->y_set)) return true;
-    return false;
+    if(cont->grid->col_dsc == NULL) return false;
+    if(cont->grid->row_dsc == NULL) return false;
+    if(cont->grid->row_dsc_len == 0) return false;
+    if(cont->grid->col_dsc_len == 0) return false;
+    if(LV_COORD_IS_GRID(obj->x_set) == false || LV_COORD_IS_GRID(obj->y_set) == false) return false;
+    return true;
 }
 
+
+/**
+ * Check if an object is valid grid item or not.
+ * @param obj pointer to an object to check
+ * @return true: grid item; false: not grid item
+ */
+bool _lv_obj_is_flex_item(struct _lv_obj_t * obj)
+{
+    lv_obj_t * cont = lv_obj_get_parent(obj);
+    if(cont == NULL) return false;
+    if(cont->flex_dir == LV_FLEX_DIR_NONE) return false;
+    if(LV_COORD_IS_FLEX(obj->x_set) == false || LV_COORD_IS_FLEX(obj->y_set) == false) return false;
+    return true;
+}
+
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -753,6 +768,13 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     lv_area_t ori;
     lv_obj_get_coords(obj, &ori);
 
+    /* Grow size is managed by the flexbox in `LV_SIGNAL_CHILD_CHG`
+     * So the real current value now.
+     * w or h has `LV_FLEX_GROW(x)` value which is a very large special value
+     * so it should be avoided to use such a special value as width*/
+    if(_LV_FLEX_GET_GROW(obj->w_set)) w = lv_obj_get_width(obj);
+    if(_LV_FLEX_GET_GROW(obj->h_set)) h = lv_obj_get_height(obj);
+
     /* Set the length and height
      * Be sure the content is not scrolled in an invalid position on the new size*/
     obj->coords.y2 = obj->coords.y1 + h - 1;
diff --git a/src/lv_core/lv_obj_pos.h b/src/lv_core/lv_obj_pos.h
index 0f440f496..4b77775e3 100644
--- a/src/lv_core/lv_obj_pos.h
+++ b/src/lv_core/lv_obj_pos.h
@@ -33,11 +33,11 @@ struct _lv_obj_t;
  * @param obj pointer to an object
  * @param x new distance from the left side of the parent plus the parent's left padding or a grid cell
  * @param y new distance from the top side of the parent  plus the parent's right padding or a grid cell
- * @note Zero value value means place the object is on the left padding of the parent, and not on the left edge.
- * @note A grid cell can be and explicit placement with cell position and span:
- *         `LV_GRID_CELL_START/END/CENTER/STRETCH(pos, span)`
- *       or "auto" to place the object on the grid in the creation order of other children
- *       `LV_GRID_AUTO_START/END/CENTER/STRETCH`
+ * @note Zero value value means place the object on the left/top padding of the parent, and not on the left/top edge.
+ * @note For grid cells: `LV_GRID_CELL_START/END/CENTER/STRETCH(pos, span)`
+ *       For flex items: `LV_FLEX_POS/START/END/CENTER`
+ *       For percentage size: `LV_SIZE_PCT(pct)`
+ *       For auto size (to set size to children size): `LV_SIZE_AUTO`
  * @note to use grid placement the parent needs have a defined grid with `lv_obj_set_grid`
  */
 void lv_obj_set_pos(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
@@ -188,7 +188,7 @@ lv_coord_t lv_obj_get_height_fit(const struct _lv_obj_t * obj);
  * @param obj pointer to an object
  * @return the height including the margins
  */
-lv_coord_t lv_obj_get_height_margin(struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_height_margin(const struct _lv_obj_t * obj);
 
 /**
  * Get the width of an object by taking the left and right margin into account.
@@ -196,28 +196,28 @@ lv_coord_t lv_obj_get_height_margin(struct _lv_obj_t * obj);
  * @param obj pointer to an object
  * @return the height including the margins
  */
-lv_coord_t lv_obj_get_width_margin(struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_width_margin(const struct _lv_obj_t * obj);
 
 /**
  * Get the width of the virtual content of an object
  * @param obj pointer to an objects
  * @return the width of the virtually drawn content
  */
-lv_coord_t _lv_obj_get_self_width(lv_obj_t * obj);
+lv_coord_t _lv_obj_get_self_width(struct _lv_obj_t * obj);
 
 /**
  * Get the height of the virtual content of an object
  * @param obj pointer to an objects
  * @return the width of the virtually drawn content
  */
-lv_coord_t _lv_obj_get_self_height(lv_obj_t * obj);
+lv_coord_t _lv_obj_get_self_height(struct _lv_obj_t * obj);
 
 /**
  * Handle if the size of the internal (virtual) content of an object has changed.
  * @param obj pointer to an object
  * @return false: nothing happened; true: refresh happened
  */
-bool _lv_obj_handle_self_size_chg(lv_obj_t * obj);
+bool _lv_obj_handle_self_size_chg(struct _lv_obj_t * obj);
 
 /**
  * Calculate the "auto size". It's `auto_size = max(gird_size, children_size)`
@@ -252,6 +252,8 @@ void _lv_obj_move_children_by(struct _lv_obj_t * obj, lv_coord_t x_diff, lv_coor
  */
 bool _lv_obj_is_grid_item(struct _lv_obj_t * obj);
 
+bool _lv_obj_is_flex_item(struct _lv_obj_t * obj);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index 49fd59c1c..4654c7579 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -209,13 +209,33 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
  *      MACROS
  **********************/
 
-#define LV_COORD_PX(x)  (x)
-#define LV_SIZE_AUTO (LV_COORD_MAX - 1)
-#define LV_SIZE_STRETCH (LV_COORD_MAX - 2)
+#define _LV_COORD_TYPE_SHIFT    (13)
+#define _LV_COORD_TYPE_MASK     (3 << _LV_COORD_TYPE_SHIFT)
+#define _LV_COORD_TYPE_PX       (0 << _LV_COORD_TYPE_SHIFT)
+#define _LV_COORD_TYPE_GRID     (1 << _LV_COORD_TYPE_SHIFT)
+#define _LV_COORD_TYPE_FLEX     (2 << _LV_COORD_TYPE_SHIFT)
+#define _LV_COORD_TYPE_SPEC     (3 << _LV_COORD_TYPE_SHIFT)
 
-#define LV_COORD_IS_PX(x)  (((x) < LV_COORD_MAX - 2) ? true : false)
-#define LV_COORD_IS_AUTO(x) (((x) == LV_SIZE_AUTO) ? true : false)
+#define LV_COORD_IS_PX(x)   ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_PX) ? true : false)
+#define LV_COORD_IS_GRID(x) ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_GRID) ? true : false)
+#define LV_COORD_IS_FLEX(x) ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_FLEX) ? true : false)
+#define LV_COORD_IS_SPEC(x) ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_SPEC) ? true : false)
 
+#define LV_COORD_GET_PX(x)   ((x) & ~(_LV_COORD_TYPE_MASK))
+#define LV_COORD_GET_GRID(x) ((x) & ~(_LV_COORD_TYPE_MASK))
+#define LV_COORD_GET_FLEX(x) ((x) & ~(_LV_COORD_TYPE_MASK))
+#define LV_COORD_GET_SPEC(x) ((x) & ~(_LV_COORD_TYPE_MASK))
+
+#define _LV_COORD_GRID(x) (_LV_COORD_TYPE_GRID | (x))
+#define _LV_COORD_FELX(x) (_LV_COORD_TYPE_FLEX | (x))
+#define _LV_COORD_SPEC(x) (_LV_COORD_TYPE_SPEC | (x))
+
+/*Special coordinates*/
+#define LV_COORD_PCT(x)      _LV_COORD_SPEC((x))
+#define LV_COORD_IS_PCT(x)   ((LV_COORD_IS_SPEC(x) && LV_COORD_GET_SPEC(x) <= 1000) ? true : false)
+#define LV_COORD_GET_PCT(x)  LV_COORD_GET_SPEC(x)
+#define LV_SIZE_AUTO        _LV_COORD_SPEC(1001)
+#define LV_SIZE_STRETCH     _LV_COORD_SPEC(1002)
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index c943aa674..3ef1bd9ae 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -25,7 +25,7 @@
  *********************/
 /*Add memory junk on alloc (0xaa) and free(0xbb) (just for testing purposes)*/
 #ifndef LV_MEM_ADD_JUNK
-    #define LV_MEM_ADD_JUNK 1
+    #define LV_MEM_ADD_JUNK 0
 #endif
 
 #ifndef LV_MEM_FULL_DEFRAG_CNT
diff --git a/src/lv_widgets/lv_checkbox.c b/src/lv_widgets/lv_checkbox.c
index 0da9ab5f5..5369395ae 100644
--- a/src/lv_widgets/lv_checkbox.c
+++ b/src/lv_widgets/lv_checkbox.c
@@ -118,9 +118,7 @@ void lv_checkbox_set_text(lv_obj_t * cb, const char * txt)
     strcpy(ext->txt, txt);
     ext->static_txt = 0;
 
-    if(cb->w_set == LV_SIZE_AUTO || cb->h_set == LV_SIZE_AUTO) {
-        lv_obj_set_size(cb, cb->w_set, cb->h_set);
-    }
+    _lv_obj_handle_self_size_chg(cb);
 }
 
 /**
@@ -138,9 +136,7 @@ void lv_checkbox_set_text_static(lv_obj_t * cb, const char * txt)
     ext->txt = txt;
     ext->static_txt = 1;
 
-    if(cb->w_set == LV_SIZE_AUTO || cb->h_set == LV_SIZE_AUTO) {
-        lv_obj_set_size(cb, cb->w_set, cb->h_set);
-    }
+    _lv_obj_handle_self_size_chg(cb);
 }
 
 /**
diff --git a/src/lv_widgets/lv_linemeter.h b/src/lv_widgets/lv_linemeter.h
new file mode 100644
index 000000000..c33bffb27
--- /dev/null
+++ b/src/lv_widgets/lv_linemeter.h
@@ -0,0 +1,170 @@
+/**
+ * @file lv_linemeter.h
+ *
+ */
+
+#ifndef LV_LINEMETER_H
+#define LV_LINEMETER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#if LV_USE_LINEMETER != 0
+
+#include "../lv_core/lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+/*Data of line meter*/
+typedef struct {
+    /*No inherited ext.*/ /*Ext. of ancestor*/
+    /*New data for this type */
+    uint16_t scale_angle; /*Angle of the scale in deg. (0..360)*/
+    uint16_t angle_ofs;
+    uint16_t line_cnt;     /*Count of lines */
+    int32_t cur_value;
+    int32_t min_value;
+    int32_t max_value;
+    uint8_t mirrored : 1;
+} lv_linemeter_ext_t;
+
+/*Styles*/
+enum {
+    LV_LINEMETER_PART_MAIN,
+    _LV_LINEMETER_PART_VIRTUAL_LAST,
+    _LV_LINEMETER_PART_REAL_LAST = _LV_OBJ_PART_REAL_LAST,
+};
+typedef uint8_t lv_linemeter_part_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a line meter objects
+ * @param par pointer to an object, it will be the parent of the new line meter
+ * @param copy pointer to a line meter object, if not NULL then the new object will be copied from
+ * it
+ * @return pointer to the created line meter
+ */
+lv_obj_t * lv_linemeter_create(lv_obj_t * par, const lv_obj_t * copy);
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Set a new value on the line meter
+ * @param lmeter pointer to a line meter object
+ * @param value new value
+ */
+void lv_linemeter_set_value(lv_obj_t * lmeter, int32_t value);
+
+/**
+ * Set minimum and the maximum values of a line meter
+ * @param lmeter pointer to he line meter object
+ * @param min minimum value
+ * @param max maximum value
+ */
+void lv_linemeter_set_range(lv_obj_t * lmeter, int32_t min, int32_t max);
+
+/**
+ * Set the scale settings of a line meter
+ * @param lmeter pointer to a line meter object
+ * @param angle angle of the scale (0..360)
+ * @param line_cnt number of lines
+ */
+void lv_linemeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint16_t line_cnt);
+
+/**
+ * Set the set an offset for the line meter's angles to rotate it.
+ * @param lmeter pointer to a line meter object
+ * @param angle angle offset (0..360), rotates clockwise
+ */
+void lv_linemeter_set_angle_offset(lv_obj_t * lmeter, uint16_t angle);
+
+/**
+ * Set the orientation of the meter growth, clockwise or counterclockwise (mirrored)
+ * @param lmeter pointer to a line meter object
+ * @param mirror mirror setting
+ */
+void lv_linemeter_set_mirror(lv_obj_t * lmeter, bool mirror);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the value of a line meter
+ * @param lmeter pointer to a line meter object
+ * @return the value of the line meter
+ */
+int32_t lv_linemeter_get_value(const lv_obj_t * lmeter);
+
+/**
+ * Get the minimum value of a line meter
+ * @param lmeter pointer to a line meter object
+ * @return the minimum value of the line meter
+ */
+int32_t lv_linemeter_get_min_value(const lv_obj_t * lmeter);
+
+/**
+ * Get the maximum value of a line meter
+ * @param lmeter pointer to a line meter object
+ * @return the maximum value of the line meter
+ */
+int32_t lv_linemeter_get_max_value(const lv_obj_t * lmeter);
+
+/**
+ * Get the scale number of a line meter
+ * @param lmeter pointer to a line meter object
+ * @return number of the scale units
+ */
+uint16_t lv_linemeter_get_line_count(const lv_obj_t * lmeter);
+
+/**
+ * Get the scale angle of a line meter
+ * @param lmeter pointer to a line meter object
+ * @return angle of the scale
+ */
+uint16_t lv_linemeter_get_scale_angle(const lv_obj_t * lmeter);
+
+/**
+ * Get the offset for the line meter.
+ * @param lmeter pointer to a line meter object
+ * @return angle offset (0..360)
+ */
+uint16_t lv_linemeter_get_angle_offset(lv_obj_t * lmeter);
+
+
+void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uint8_t part);
+
+/**
+ * get the mirror setting for the line meter
+ * @param lmeter pointer to a line meter object
+ * @return mirror (true or false)
+ */
+bool lv_linemeter_get_mirror(lv_obj_t * lmeter);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_LINEMETER*/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_LINEMETER_H*/
diff --git a/src/lv_widgets/lv_roller.c b/src/lv_widgets/lv_roller.c
index 7afea7900..31109fd71 100644
--- a/src/lv_widgets/lv_roller.c
+++ b/src/lv_widgets/lv_roller.c
@@ -597,7 +597,7 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
         lv_obj_t * label = get_label(roller);
         /*Be sure the label's style is updated before processing the roller*/
         if(label) lv_signal_send(label, LV_SIGNAL_STYLE_CHG, NULL);
-        lv_obj_set_width(roller, roller->w_set);
+        _lv_obj_handle_self_size_chg(roller);
         refr_position(roller, false);
     }
     else if(sign == LV_SIGNAL_COORD_CHG) {

From c61609f6eeaf04348709cb306f427034ede4be95 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 16 Oct 2020 16:00:05 +0200
Subject: [PATCH 56/84] minor fixes

---
 src/lv_core/lv_flex.c             | 27 +++++++++++++++++++--------
 src/lv_core/lv_obj.c              |  9 +++++----
 src/lv_core/lv_obj_pos.c          | 10 +++-------
 src/lv_themes/lv_theme_material.c | 23 ++++++++++++++++-------
 4 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index 4e052b470..db4cea062 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -38,7 +38,7 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
 
 void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir)
 {
-    if(obj->flex_dir != flex_dir) return;
+    if(obj->flex_dir == flex_dir) return;
 
     obj->flex_dir = flex_dir;
     _lv_flex_refresh(obj);
@@ -170,9 +170,12 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
 
 static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_dir_t main_dir, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
 {
-    lv_coord_t(*get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    void (*set_main_size)(lv_obj_t *, lv_coord_t) = (main_dir == LV_DIR_HOR ? lv_obj_set_width_margin : lv_obj_set_height_margin);
-    lv_coord_t(*get_cross_size)(const lv_obj_t *) = (main_dir ==  LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (main_dir ==  LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (main_dir == LV_DIR_HOR ? lv_area_set_width : lv_area_set_height);
+    lv_coord_t (*area_get_main_size)(const lv_area_t *) = (main_dir == LV_DIR_HOR ? lv_area_get_width : lv_area_get_height);
+    lv_coord_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
+    lv_coord_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
 
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
@@ -189,17 +192,25 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
         if(_LV_FLEX_GET_GROW(main_size)) {
             lv_coord_t s =  _LV_FLEX_GET_GROW(main_size) * grow_unit;
-            set_main_size(item, s);
+            s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_start(item, LV_OBJ_PART_MAIN);
+            if(s != area_get_main_size(&item->coords)) {
+                lv_area_t old_coords;
+                lv_area_copy(&old_coords, &item->coords);
+                lv_obj_invalidate(item);
+                area_set_main_size(&item->coords, s);
+                lv_obj_invalidate(item);
+                item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
+            }
         }
 
         lv_coord_t cross_pos = 0;
         lv_coord_t cross_set = (main_dir == LV_DIR_HOR ? item->y_set : item->x_set);
         switch(cross_set) {
         case LV_FLEX_CENTER:
-            cross_pos = (track_size - get_cross_size(item)) / 2;
+            cross_pos = (track_size - obj_get_cross_size(item)) / 2;
             break;
         case LV_FLEX_END:
-            cross_pos = track_size - get_cross_size(item);
+            cross_pos = track_size - obj_get_cross_size(item);
             break;
         }
 
@@ -220,7 +231,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             item->coords.y2 += diff_y;
             _lv_obj_move_children_by(item, diff_x, diff_y);
         }
-        main_pos += get_main_size(item);
+        main_pos += obj_get_main_size(item);
         item = _lv_ll_get_prev(&cont->child_ll, item);
     }
 }
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 414d2f946..c9a05d116 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1915,12 +1915,13 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
 
         if(w_new || h_new) {
-            lv_coord_t cont_w = lv_obj_get_width_fit(obj);
-            lv_coord_t cont_h = lv_obj_get_height_fit(obj);
             lv_obj_t * child;
             _LV_LL_READ(obj->child_ll, child) {
-                if(LV_COORD_IS_PCT(child->w_set) && w_new) lv_obj_set_width(child, (LV_COORD_GET_PCT(child->w_set) * cont_w) / 100);
-                if(LV_COORD_IS_PCT(child->h_set) && h_new) lv_obj_set_height(child, (LV_COORD_GET_PCT(child->h_set) * cont_h) / 100);
+                if((LV_COORD_IS_PCT(child->w_set) && w_new) ||
+                        (LV_COORD_IS_PCT(child->h_set) && h_new))
+                {
+                    lv_obj_set_size(child, child->w_set, child->h_set);
+                }
             }
             if(obj->grid) _lv_grid_full_refresh(obj);
             if(obj->flex_dir) _lv_flex_refresh(obj);
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 54be84cf5..06c744e38 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -259,10 +259,6 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 
     LV_ASSERT_OBJ(base, LV_OBJX_NAME);
 
-//    lv_point_t new_pos;
-//    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
-
-
     lv_coord_t x;
     lv_coord_t y;
     switch(align) {
@@ -280,7 +276,7 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
         break;
 
     case LV_ALIGN_IN_TOP_RIGHT:
-        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
+        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
         y = 0;
         break;
 
@@ -369,8 +365,8 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
         break;
     }
 
-    x += x_ofs;
-    y += y_ofs;
+    x += x_ofs + base->coords.x1;
+    y += y_ofs + base->coords.y1;
 
     lv_obj_set_pos(obj, x, y);
 }
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 49c4934c5..82f5082ae 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -76,6 +76,7 @@
  **********************/
 typedef struct {
     lv_style_t scr;
+    lv_style_t sb;
     lv_style_t bg;
     lv_style_t bg_click;
     lv_style_t bg_sec;
@@ -202,6 +203,13 @@ static bool inited;
 
 static void basic_init(void)
 {
+    lv_style_set_scrollbar_bg_opa(&styles->sb, LV_STATE_DEFAULT, LV_OPA_COVER);
+    lv_style_set_scrollbar_bg_color(&styles->sb, LV_STATE_DEFAULT, (IS_LIGHT ? lv_color_hex(0xcccfd1) : lv_color_hex(0x777f85)));
+    lv_style_set_scrollbar_radius(&styles->sb, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+    lv_style_set_scrollbar_tickness(&styles->sb, LV_STATE_DEFAULT, LV_DPX(7));
+    lv_style_set_scrollbar_space_side(&styles->sb, LV_STATE_DEFAULT,  LV_DPX(7));
+    lv_style_set_scrollbar_space_end(&styles->sb, LV_STATE_DEFAULT,  LV_DPX(7));
+
     style_init_reset(&styles->scr);
     lv_style_set_bg_opa(&styles->scr, LV_STATE_DEFAULT, LV_OPA_COVER);
     lv_style_set_bg_color(&styles->scr, LV_STATE_DEFAULT, COLOR_SCR);
@@ -228,13 +236,6 @@ static void basic_init(void)
     lv_style_set_line_color(&styles->bg, LV_STATE_DEFAULT, COLOR_BG_TEXT);
     lv_style_set_line_width(&styles->bg, LV_STATE_DEFAULT, 1);
 
-    lv_style_set_scrollbar_bg_opa(&styles->bg, LV_STATE_DEFAULT, LV_OPA_COVER);
-    lv_style_set_scrollbar_bg_color(&styles->bg, LV_STATE_DEFAULT, (IS_LIGHT ? lv_color_hex(0xcccfd1) : lv_color_hex(0x777f85)));
-    lv_style_set_scrollbar_radius(&styles->bg, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-    lv_style_set_scrollbar_tickness(&styles->bg, LV_STATE_DEFAULT, LV_DPX(7));
-    lv_style_set_scrollbar_space_side(&styles->bg, LV_STATE_DEFAULT,  LV_DPX(7));
-    lv_style_set_scrollbar_space_end(&styles->bg, LV_STATE_DEFAULT,  LV_DPX(7));
-
     lv_style_set_pad_left(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_right(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
     lv_style_set_pad_top(&styles->bg, LV_STATE_DEFAULT, PAD_DEF + BORDER_WIDTH);
@@ -979,10 +980,12 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
         case LV_THEME_SCR:
             list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->scr);
+            _lv_style_list_add_style(list, &styles->sb);
             break;
         case LV_THEME_OBJ:
             list = _lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
+            _lv_style_list_add_style(list, &styles->sb);
             break;
 
 #if LV_USE_BTN
@@ -1070,6 +1073,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->arc_bg);
+            _lv_style_list_add_style(list, &styles->sb);
 
             list = _lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
@@ -1109,6 +1113,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
         case LV_THEME_CHECKBOX:
             list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_MAIN);
             _lv_style_list_add_style(list, &styles->cb_bg);
+            _lv_style_list_add_style(list, &styles->sb);
 
             list = _lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->btn);
@@ -1198,6 +1203,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->roller_bg);
+            _lv_style_list_add_style(list, &styles->sb);
 
             list = _lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->roller_sel);
@@ -1237,6 +1243,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->ddlist_page);
+            _lv_style_list_add_style(list, &styles->sb);
 
             list = _lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->ddlist_sel);
@@ -1263,6 +1270,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
         {
             list = _lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
+            _lv_style_list_add_style(list, &styles->sb);
 
             int idx = 1; /* start value should be 1, not zero, since cell styles 
                             start at 1 due to presence of LV_TABLE_PART_BG=0
@@ -1302,6 +1310,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
+            _lv_style_list_add_style(list, &styles->sb);
 
             list = _lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_style_list_add_style(list, &styles->ta_placeholder);

From cfed728714bda4f49f37f598e8887a17da6a2d4d Mon Sep 17 00:00:00 2001
From: Themba Dube <embeddedthemba@gmail.com>
Date: Sun, 18 Oct 2020 08:20:53 -0400
Subject: [PATCH 57/84] Remove typedef from lv_obj.h as it is now in lv_grid.h

---
 src/lv_core/lv_obj.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index c43c48b4c..4b1582296 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -208,7 +208,7 @@ typedef uint16_t lv_obj_flag_t;
 #include "lv_obj_draw.h"
 
 
-typedef struct _lv_obj_t {
+struct _lv_obj_t {
     struct _lv_obj_t * parent; /**< Pointer to the parent object*/
     lv_ll_t child_ll;       /**< Linked list to store the children objects*/
 
@@ -258,7 +258,7 @@ typedef struct _lv_obj_t {
 
     uint8_t flex_dir;
 
-} lv_obj_t;
+};
 
 enum {
     LV_OBJ_PART_MAIN,

From 9e349fe625ac633d1421fc003595ed7b24a55091 Mon Sep 17 00:00:00 2001
From: Themba Dube <embeddedthemba@gmail.com>
Date: Sun, 18 Oct 2020 09:58:16 -0400
Subject: [PATCH 58/84] Update version to 8.0.0-dev

---
 lvgl.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lvgl.h b/lvgl.h
index 102ab1caa..7be04f10d 100644
--- a/lvgl.h
+++ b/lvgl.h
@@ -14,8 +14,8 @@ extern "C" {
 /***************************
  * CURRENT VERSION OF LVGL
  ***************************/
-#define LVGL_VERSION_MAJOR 7
-#define LVGL_VERSION_MINOR 7
+#define LVGL_VERSION_MAJOR 8
+#define LVGL_VERSION_MINOR 0
 #define LVGL_VERSION_PATCH 0
 #define LVGL_VERSION_INFO "dev"
 

From e8aaaccc8e3e91464d51ac1f3cf35b481f2d9afd Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 19 Oct 2020 16:01:39 +0200
Subject: [PATCH 59/84] flex: add reverse direction bit

---
 src/lv_core/lv_flex.c | 44 ++++++++++++++-----------------------------
 src/lv_core/lv_flex.h |  5 +++--
 2 files changed, 17 insertions(+), 32 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index db4cea062..257617966 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -53,21 +53,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
 {
     if(cont->flex_dir == LV_FLEX_DIR_NONE) return;
 
-    lv_dir_t main_dir;
-    switch(cont->flex_dir) {
-    case LV_FLEX_DIR_ROW:
-        main_dir = LV_DIR_HOR;
-        break;
-    case LV_FLEX_DIR_ROW_WRAP:
-        main_dir = LV_DIR_HOR;
-        break;
-    case LV_FLEX_DIR_COLUMN:
-        main_dir = LV_DIR_VER;
-        break;
-    case LV_FLEX_DIR_COLUMN_WRAP:
-        main_dir = LV_DIR_VER;
-        break;
-    }
+    lv_dir_t main_dir = cont->flex_dir & LV_FLEX_DIR_ROW ?  LV_DIR_HOR : LV_DIR_VER;
 
     /*Count the grow units and free space*/
     lv_coord_t max_main_size = (main_dir == LV_DIR_HOR ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
@@ -84,9 +70,11 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t track_size;
     lv_obj_t * track_first_item;
     lv_obj_t * next_track_first_item;
+    bool rev = cont->flex_dir & LV_FLEX_REVERSE;
 
     if(row_place != LV_FLEX_START) {
-        track_first_item = _lv_ll_get_tail(&cont->child_ll);
+        track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
+
         while(track_first_item) {
             /*Search the first item of the next row */
             next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
@@ -99,7 +87,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
         place_content(row_place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
     }
 
-    track_first_item = _lv_ll_get_tail(&cont->child_ll);
+    track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
     while(track_first_item) {
         /*Search the first item of the next row */
         next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
@@ -119,13 +107,8 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
 {
     lv_coord_t(*get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*get_cross_size)(const lv_obj_t *) = (main_dir == LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-
-    bool wrap;
-    if(cont->flex_dir == LV_FLEX_DIR_ROW_WRAP || cont->flex_dir == LV_FLEX_DIR_COLUMN_WRAP) {
-        wrap = true;
-    } else {
-        wrap = false;
-    }
+    void * (*ll_iter)(const lv_ll_t * , const void *) = cont->flex_dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
+    bool wrap = cont->flex_dir & LV_FLEX_WRAP ? true : false;
 
     lv_coord_t grow_sum = 0;
     lv_coord_t used_size = 0;
@@ -137,7 +120,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
         /*Ignore non-flex items*/
         lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
-            item = _lv_ll_get_prev(&cont->child_ll, item);
+            item = ll_iter(&cont->child_ll, item);
             continue;
         }
 
@@ -152,7 +135,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
 
         *track_cross_size = LV_MATH_MAX(get_cross_size(item), *track_cross_size);
 
-        item = _lv_ll_get_prev(&cont->child_ll, item);
+        item = ll_iter(&cont->child_ll, item);
     }
 
     *grow_unit = grow_sum ? (max_size - used_size) / grow_sum : 0;
@@ -160,7 +143,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
 
     /*Have at least one item in a row*/
     if(item && item == item_start) {
-        item = _lv_ll_get_prev(&cont->child_ll, item);
+        item = ll_iter(&cont->child_ll, item);
         if(item) *track_cross_size = get_cross_size(item);
     }
 
@@ -176,6 +159,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
     lv_coord_t (*area_get_main_size)(const lv_area_t *) = (main_dir == LV_DIR_HOR ? lv_area_get_width : lv_area_get_height);
     lv_coord_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
     lv_coord_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
+    void * (*ll_iter)(const lv_ll_t * , const void *) = cont->flex_dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
 
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
@@ -185,14 +169,14 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         /*Ignore non-flex items*/
         lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
-            item = _lv_ll_get_prev(&cont->child_ll, item);
+            item = ll_iter(&cont->child_ll, item);
             continue;
         }
 
         lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
         if(_LV_FLEX_GET_GROW(main_size)) {
             lv_coord_t s =  _LV_FLEX_GET_GROW(main_size) * grow_unit;
-            s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_start(item, LV_OBJ_PART_MAIN);
+            s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_end(item, LV_OBJ_PART_MAIN);
             if(s != area_get_main_size(&item->coords)) {
                 lv_area_t old_coords;
                 lv_area_copy(&old_coords, &item->coords);
@@ -232,7 +216,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             _lv_obj_move_children_by(item, diff_x, diff_y);
         }
         main_pos += obj_get_main_size(item);
-        item = _lv_ll_get_prev(&cont->child_ll, item);
+        item = ll_iter(&cont->child_ll, item);
     }
 }
 
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 07ab06da4..4435fa238 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -24,6 +24,9 @@ extern "C" {
 
 #define _LV_FLEX_GET_GROW(v) (LV_COORD_IS_FLEX(v) ? LV_COORD_GET_FLEX(v) : 0)
 
+#define LV_FLEX_WRAP       (1 << 6)
+#define LV_FLEX_REVERSE    (1 << 7)
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -40,9 +43,7 @@ typedef enum {
 typedef enum {
     LV_FLEX_DIR_NONE,
     LV_FLEX_DIR_ROW,
-    LV_FLEX_DIR_ROW_WRAP,
     LV_FLEX_DIR_COLUMN,
-    LV_FLEX_DIR_COLUMN_WRAP,
 } lv_flex_dir_t;
 
 /**********************

From 5dadb03ae61585434833ad2489f3fdfddb5e97a3 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 19 Oct 2020 16:02:02 +0200
Subject: [PATCH 60/84] minor scroll improvements

---
 src/lv_core/lv_indev.c        |  2 ++
 src/lv_core/lv_indev_scroll.c |  4 ++--
 src/lv_core/lv_obj_pos.c      |  4 ++--
 src/lv_core/lv_obj_scroll.c   | 19 ++++++++++++++++++-
 src/lv_core/lv_obj_scroll.h   |  7 +++++++
 src/lv_hal/lv_hal_indev.h     |  1 +
 src/lv_misc/lv_area.h         |  2 +-
 7 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index a9ca7e463..a1063270f 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -910,6 +910,8 @@ static void indev_proc_press(lv_indev_proc_t * proc)
     proc->types.pointer.scroll_throw_vect.x += (proc->types.pointer.vect.x * 4) >> 3;
     proc->types.pointer.scroll_throw_vect.y += (proc->types.pointer.vect.y * 4) >> 3;
 
+    proc->types.pointer.scroll_throw_vect_ori = proc->types.pointer.scroll_throw_vect;
+
     if(indev_obj_act) {
         lv_signal_send(indev_obj_act, LV_SIGNAL_PRESSING, indev_act);
         if(indev_reset_check(proc)) return;
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index c9cd02ee2..c9f97e319 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -215,10 +215,10 @@ lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir)
     lv_coord_t v;
     switch(dir) {
     case LV_DIR_VER:
-        v = indev->proc.types.pointer.scroll_throw_vect.y;
+        v = indev->proc.types.pointer.scroll_throw_vect_ori.y;
         break;
     case LV_DIR_HOR:
-        v = indev->proc.types.pointer.scroll_throw_vect.x;
+        v = indev->proc.types.pointer.scroll_throw_vect_ori.x;
         break;
     default:
         return 0;
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 06c744e38..36e3ce387 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -158,8 +158,8 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     if(parent) {
         lv_coord_t cont_w = lv_obj_get_width_fit(parent);
         lv_coord_t cont_h = lv_obj_get_height_fit(parent);
-        if(pct_w) w = (LV_COORD_GET_PCT(obj->w_set) * cont_w) / 100;
-        if(pct_h) h = (LV_COORD_GET_PCT(obj->h_set) * cont_h) / 100;
+        if(pct_w) w = (_LV_COORD_GET_PCT(obj->w_set) * cont_w) / 100;
+        if(pct_h) h = (_LV_COORD_GET_PCT(obj->h_set) * cont_h) / 100;
     }
 
     refr_size(obj, w, h);
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 1e6547ad9..80a8f1fce 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -136,7 +136,8 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  */
 void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-
+    lv_obj_scroll_to_x(obj, x, anim_en);
+    lv_obj_scroll_to_y(obj, y, anim_en);
 }
 
 /**
@@ -258,6 +259,22 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
     return LV_MATH_MAX(child_res, self_w);
 }
 
+/**
+ * Get the X and Y coordinates where the scrolling would end for this object if a scrolling animation is in progress.
+ * In no scrolling animation give the current `left` or `top` scroll position.
+ * @param obj pointer to an object
+ * @param end poinr to point to store the result
+ */
+void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
+{
+    lv_anim_t * a;
+    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_x_cb);
+    end->x = a ? -a->end : lv_obj_get_scroll_left(obj);
+
+    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_y_cb);
+    end->y = a ? -a->end : lv_obj_get_scroll_top(obj);
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index 191d7c94e..39ce98686 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -140,6 +140,13 @@ lv_coord_t lv_obj_get_scroll_left(const struct _lv_obj_t * obj);
  */
 lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
 
+/**
+ * Get the X and Y coordinates where the scrolling would end for this object if a scrolling animation is in progress.
+ * In no scrolling animation give the current `left` or `top` scroll position.
+ * @param obj pointer to an object
+ * @param end poinr to point to store the result
+ */
+void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end);
 
 /**********************
  *      MACROS
diff --git a/src/lv_hal/lv_hal_indev.h b/src/lv_hal/lv_hal_indev.h
index 846bd63e4..43fcd33bc 100644
--- a/src/lv_hal/lv_hal_indev.h
+++ b/src/lv_hal/lv_hal_indev.h
@@ -134,6 +134,7 @@ typedef struct _lv_indev_proc_t {
             lv_point_t vect; /**< Difference between `act_point` and `last_point`. */
             lv_point_t scroll_sum; /*Count the dragged pixels to check LV_INDEV_DEF_DRAG_LIMIT*/
             lv_point_t scroll_throw_vect;
+            lv_point_t scroll_throw_vect_ori;
             struct _lv_obj_t * act_obj;      /*The object being pressed*/
             struct _lv_obj_t * last_obj;     /*The last object which was pressed (used by drag_throw and
                                                 other post-release event)*/
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index 4654c7579..c0602f644 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -233,7 +233,7 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
 /*Special coordinates*/
 #define LV_COORD_PCT(x)      _LV_COORD_SPEC((x))
 #define LV_COORD_IS_PCT(x)   ((LV_COORD_IS_SPEC(x) && LV_COORD_GET_SPEC(x) <= 1000) ? true : false)
-#define LV_COORD_GET_PCT(x)  LV_COORD_GET_SPEC(x)
+#define _LV_COORD_GET_PCT(x)  LV_COORD_GET_SPEC(x)
 #define LV_SIZE_AUTO        _LV_COORD_SPEC(1001)
 #define LV_SIZE_STRETCH     _LV_COORD_SPEC(1002)
 

From e3fedd29c9f89ca71982ba26e4b439ceef9edbd4 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 22 Oct 2020 14:19:49 +0200
Subject: [PATCH 61/84] simpilfy flex constants

---
 src/lv_core/lv_flex.c    | 12 +++++++-----
 src/lv_core/lv_flex.h    | 14 +++++++-------
 src/lv_core/lv_obj.h     |  4 +++-
 src/lv_core/lv_obj_pos.c | 31 ++++++++++++++++---------------
 4 files changed, 33 insertions(+), 28 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index 257617966..e2c036467 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -36,17 +36,19 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir)
+void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place)
 {
     if(obj->flex_dir == flex_dir) return;
 
     obj->flex_dir = flex_dir;
+    obj->flex_place = flex_place;
     _lv_flex_refresh(obj);
 }
 
 void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
 {
-    lv_obj_set_pos(obj, place, place);
+    lv_coord_t f  = _LV_COORD_FELX(place);
+    lv_obj_set_pos(obj, f, f);
 }
 
 void _lv_flex_refresh(lv_obj_t * cont)
@@ -62,7 +64,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
 
     lv_coord_t * cross_pos = (main_dir == LV_DIR_HOR ? &abs_y : &abs_x);
 
-    lv_coord_t row_place = LV_FLEX_START;
+    lv_coord_t place = cont->flex_place;
     lv_coord_t all_track_size = 0;
     lv_coord_t gap = 0;
     uint32_t row_cnt = 0;
@@ -72,7 +74,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_obj_t * next_track_first_item;
     bool rev = cont->flex_dir & LV_FLEX_REVERSE;
 
-    if(row_place != LV_FLEX_START) {
+    if(place != LV_FLEX_START) {
         track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
 
         while(track_first_item) {
@@ -84,7 +86,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
         }
 
         lv_coord_t max_cross_size = (main_dir == LV_DIR_HOR ? lv_obj_get_height_fit(cont) : lv_obj_get_width_fit(cont));
-        place_content(row_place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
+        place_content(place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
     }
 
     track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 4435fa238..157bdb036 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -32,12 +32,12 @@ extern "C" {
  **********************/
 
 typedef enum {
-    LV_FLEX_START = _LV_COORD_FELX(0),
-    LV_FLEX_END = _LV_COORD_FELX(1),
-    LV_FLEX_CENTER = _LV_COORD_FELX(2),
-    LV_FLEX_SPACE_EVENLY = _LV_COORD_FELX(3),
-    LV_FLEX_SPACE_AROUND = _LV_COORD_FELX(4),
-    LV_FLEX_SPACE_BETWEEN = _LV_COORD_FELX(5),
+    LV_FLEX_START,
+    LV_FLEX_END,
+    LV_FLEX_CENTER,
+    LV_FLEX_SPACE_EVENLY,
+    LV_FLEX_SPACE_AROUND,
+    LV_FLEX_SPACE_BETWEEN,
 }lv_flex_place_t;
 
 typedef enum {
@@ -50,7 +50,7 @@ typedef enum {
  * GLOBAL PROTOTYPES
  **********************/
 
-void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir);
+void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place);
 void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
 void _lv_flex_refresh(lv_obj_t * cont);
 
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 4b1582296..9ecd8562b 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -256,7 +256,9 @@ struct _lv_obj_t {
 
     const lv_grid_t * grid;
 
-    uint8_t flex_dir;
+    uint8_t flex_dir   : 4;
+    uint8_t flex_place : 4;
+
 
 };
 
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 36e3ce387..2d843eda6 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -263,15 +263,15 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
     lv_coord_t y;
     switch(align) {
     case LV_ALIGN_CENTER:
-        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
-        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
         break;
     case LV_ALIGN_IN_TOP_LEFT:
         x = 0;
         y = 0;
         break;
     case LV_ALIGN_IN_TOP_MID:
-        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
+        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
         y = 0;
         break;
 
@@ -282,26 +282,26 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 
     case LV_ALIGN_IN_BOTTOM_LEFT:
         x = 0;
-        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
         break;
     case LV_ALIGN_IN_BOTTOM_MID:
-        x = lv_obj_get_width_fit(base) / 2 - lv_obj_get_width_fit(obj) / 2;
-        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_IN_BOTTOM_RIGHT:
-        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
-        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
         break;
 
     case LV_ALIGN_IN_LEFT_MID:
         x = 0;
-        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
         break;
 
     case LV_ALIGN_IN_RIGHT_MID:
-        x = lv_obj_get_width_fit(base) - lv_obj_get_width_fit(obj);
-        y = lv_obj_get_height_fit(base) / 2 - lv_obj_get_height_fit(obj) / 2;
+        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
         break;
 
     case LV_ALIGN_OUT_TOP_LEFT:
@@ -360,13 +360,14 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
         break;
 
     case LV_ALIGN_OUT_RIGHT_BOTTOM:
-        x = lv_obj_get_width_fit(base);
-        y = lv_obj_get_height_fit(base) - lv_obj_get_height_fit(obj);
+        x = lv_obj_get_width(base);
+        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
         break;
     }
 
-    x += x_ofs + base->coords.x1;
-    y += y_ofs + base->coords.y1;
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    x += x_ofs + base->coords.x1 - parent->coords.x1 - lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
+    y += y_ofs + base->coords.y1 - parent->coords.y1 - lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
 
     lv_obj_set_pos(obj, x, y);
 }

From 9fc88b653507da40690c2471e4ef32d99a9e3f10 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 26 Oct 2020 15:46:21 +0100
Subject: [PATCH 62/84] minor fixes

---
 src/lv_core/lv_flex.c             |  113 +--
 src/lv_core/lv_flex.h             |   13 +-
 src/lv_core/lv_obj.c              |   33 +-
 src/lv_core/lv_obj.h              |   14 +-
 src/lv_core/lv_obj_pos.c          |    2 +-
 src/lv_core/lv_obj_scroll.c       |    3 -
 src/lv_themes/lv_theme_material.c |   11 +-
 src/lv_widgets/lv_btnmatrix.c     |    1 +
 src/lv_widgets/lv_calendar.c      | 1091 -----------------------------
 src/lv_widgets/lv_cont.c          |  805 ---------------------
 10 files changed, 131 insertions(+), 1955 deletions(-)
 delete mode 100644 src/lv_widgets/lv_calendar.c
 delete mode 100644 src/lv_widgets/lv_cont.c

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index e2c036467..ab80f13d6 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -20,8 +20,8 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_t main_dir, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size);
-static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_dir_t main_dir, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit);
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size);
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit);
 static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
 
 /**********************
@@ -38,10 +38,21 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
 
 void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place)
 {
-    if(obj->flex_dir == flex_dir) return;
+    if(obj->flex_cont.dir == flex_dir && obj->flex_cont.place == flex_place) return;
+
+    obj->flex_cont.dir = flex_dir;
+    obj->flex_cont.place = flex_place;
+
+    _lv_flex_refresh(obj);
+}
+
+void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
+{
+
+    if(obj->flex_cont.gap == gap) return;
+
+    obj->flex_cont.gap = gap;
 
-    obj->flex_dir = flex_dir;
-    obj->flex_place = flex_place;
     _lv_flex_refresh(obj);
 }
 
@@ -53,18 +64,24 @@ void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
 
 void _lv_flex_refresh(lv_obj_t * cont)
 {
-    if(cont->flex_dir == LV_FLEX_DIR_NONE) return;
-
-    lv_dir_t main_dir = cont->flex_dir & LV_FLEX_DIR_ROW ?  LV_DIR_HOR : LV_DIR_VER;
+    if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return;
 
+    lv_flex_dir_t dir = cont->flex_cont.dir;
+    bool row = dir == LV_FLEX_DIR_ROW ? true : false;
     /*Count the grow units and free space*/
-    lv_coord_t max_main_size = (main_dir == LV_DIR_HOR ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
+    lv_coord_t max_main_size = (row ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
 
-    lv_coord_t * cross_pos = (main_dir == LV_DIR_HOR ? &abs_y : &abs_x);
+    lv_coord_t * cross_pos = (dir == LV_FLEX_DIR_ROW ? &abs_y : &abs_x);
+
+    lv_coord_t place = cont->flex_cont.place;
+    if((row && cont->h_set == LV_SIZE_AUTO) ||
+       (!row && cont->w_set == LV_SIZE_AUTO))
+    {
+        place = LV_FLEX_START;
+    }
 
-    lv_coord_t place = cont->flex_place;
     lv_coord_t all_track_size = 0;
     lv_coord_t gap = 0;
     uint32_t row_cnt = 0;
@@ -72,29 +89,29 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t track_size;
     lv_obj_t * track_first_item;
     lv_obj_t * next_track_first_item;
-    bool rev = cont->flex_dir & LV_FLEX_REVERSE;
+    bool rev = cont->flex_cont.dir & LV_FLEX_REVERSE;
 
     if(place != LV_FLEX_START) {
         track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
 
         while(track_first_item) {
             /*Search the first item of the next row */
-            next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
+            next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
             all_track_size += track_size;
             row_cnt++;
             track_first_item = next_track_first_item;
         }
 
-        lv_coord_t max_cross_size = (main_dir == LV_DIR_HOR ? lv_obj_get_height_fit(cont) : lv_obj_get_width_fit(cont));
+        lv_coord_t max_cross_size = (row ? lv_obj_get_height_fit(cont) : lv_obj_get_width_fit(cont));
         place_content(place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
     }
 
     track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
     while(track_first_item) {
         /*Search the first item of the next row */
-        next_track_first_item = find_track_end(cont, track_first_item, main_dir, max_main_size, &grow_unit, &track_size);
+        next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
 
-        children_repos(cont, track_first_item, next_track_first_item, main_dir, abs_x, abs_y, track_size, grow_unit);
+        children_repos(cont, track_first_item, next_track_first_item, abs_x, abs_y, track_size, grow_unit);
 
         track_first_item = next_track_first_item;
         *cross_pos += track_size + gap;
@@ -105,43 +122,54 @@ void _lv_flex_refresh(lv_obj_t * cont)
  *   STATIC FUNCTIONS
  **********************/
 
-static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_t main_dir, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
 {
-    lv_coord_t(*get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    lv_coord_t(*get_cross_size)(const lv_obj_t *) = (main_dir == LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    void * (*ll_iter)(const lv_ll_t * , const void *) = cont->flex_dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
-    bool wrap = cont->flex_dir & LV_FLEX_WRAP ? true : false;
+    lv_flex_dir_t dir = cont->flex_cont.dir;
+    bool row = dir == LV_FLEX_DIR_ROW ? true : false;
+    lv_coord_t(*get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
+    bool wrap = dir & LV_FLEX_WRAP ? true : false;
 
     lv_coord_t grow_sum = 0;
     lv_coord_t used_size = 0;
+    lv_coord_t gap = cont->flex_cont.gap;
+    uint32_t grow_item_cnt = 0;
     *track_cross_size = 0;
     *grow_unit = 0;
 
     lv_obj_t * item = item_start;
     while(item) {
         /*Ignore non-flex items*/
-        lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
+        lv_coord_t main_set = (row ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
             item = ll_iter(&cont->child_ll, item);
             continue;
         }
 
-        lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
+        lv_coord_t main_size = (row ? item->w_set : item->h_set);
         if(_LV_FLEX_GET_GROW(main_size)) {
             grow_sum += _LV_FLEX_GET_GROW(main_size);
+            grow_item_cnt++;
         } else {
-            lv_coord_t item_size = get_main_size(item);
+            lv_coord_t item_size = get_main_size(item) + gap;
             if(wrap && used_size + item_size > max_size) break;
             used_size += item_size;
         }
-
         *track_cross_size = LV_MATH_MAX(get_cross_size(item), *track_cross_size);
 
         item = ll_iter(&cont->child_ll, item);
     }
 
-    *grow_unit = grow_sum ? (max_size - used_size) / grow_sum : 0;
-    if(*grow_unit < 0) *grow_unit = 0;
+    if(used_size > 0) used_size -= gap; /*There is no gap after the last item*/
+
+    if(grow_item_cnt && grow_sum) {
+        lv_coord_t s = max_size - used_size;
+        s -= grow_item_cnt * gap;
+        *grow_unit =  s / grow_sum;
+    } else {
+        *grow_unit = 0;
+    }
 
     /*Have at least one item in a row*/
     if(item && item == item_start) {
@@ -153,29 +181,32 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_dir_
 }
 
 
-static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_dir_t main_dir, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
 {
-    lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (main_dir == LV_DIR_HOR ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (main_dir ==  LV_DIR_VER ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (main_dir == LV_DIR_HOR ? lv_area_set_width : lv_area_set_height);
-    lv_coord_t (*area_get_main_size)(const lv_area_t *) = (main_dir == LV_DIR_HOR ? lv_area_get_width : lv_area_get_height);
-    lv_coord_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
-    lv_coord_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (main_dir == LV_DIR_HOR ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
-    void * (*ll_iter)(const lv_ll_t * , const void *) = cont->flex_dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
+    lv_flex_dir_t dir = cont->flex_cont.dir;
+    bool row = dir == LV_FLEX_DIR_ROW ? true : false;
+    lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
+    void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (row ? lv_area_set_width : lv_area_set_height);
+    lv_coord_t (*area_get_main_size)(const lv_area_t *) = (!row ? lv_area_get_width : lv_area_get_height);
+    lv_style_int_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
+    lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
+    void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
 
+    lv_coord_t gap = cont->flex_cont.gap;
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
     lv_obj_t * item = item_first;   /*Just to use a shorter name*/
     while(item != item_last) {
 
         /*Ignore non-flex items*/
-        lv_coord_t main_set = (main_dir == LV_DIR_HOR ? item->x_set : item->y_set);
+        lv_coord_t main_set = (row ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
             item = ll_iter(&cont->child_ll, item);
             continue;
         }
 
-        lv_coord_t main_size = (main_dir == LV_DIR_HOR ? item->w_set : item->h_set);
+        lv_coord_t main_size = (row ? item->w_set : item->h_set);
         if(_LV_FLEX_GET_GROW(main_size)) {
             lv_coord_t s =  _LV_FLEX_GET_GROW(main_size) * grow_unit;
             s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_end(item, LV_OBJ_PART_MAIN);
@@ -190,8 +221,8 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         }
 
         lv_coord_t cross_pos = 0;
-        lv_coord_t cross_set = (main_dir == LV_DIR_HOR ? item->y_set : item->x_set);
-        switch(cross_set) {
+        lv_coord_t cross_set = (row ? item->y_set : item->x_set);
+        switch(LV_COORD_GET_FLEX(cross_set)) {
         case LV_FLEX_CENTER:
             cross_pos = (track_size - obj_get_cross_size(item)) / 2;
             break;
@@ -202,7 +233,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
 
         lv_coord_t diff_x;
         lv_coord_t diff_y;
-        if(main_dir == LV_DIR_HOR) {
+        if(row) {
             diff_x = abs_x + main_pos - item->coords.x1;
             diff_y = abs_y + cross_pos - item->coords.y1;
         } else {
@@ -217,7 +248,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             item->coords.y2 += diff_y;
             _lv_obj_move_children_by(item, diff_x, diff_y);
         }
-        main_pos += obj_get_main_size(item);
+        main_pos += obj_get_main_size(item) + gap;
         item = ll_iter(&cont->child_ll, item);
     }
 }
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 157bdb036..884300f4a 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -24,8 +24,8 @@ extern "C" {
 
 #define _LV_FLEX_GET_GROW(v) (LV_COORD_IS_FLEX(v) ? LV_COORD_GET_FLEX(v) : 0)
 
-#define LV_FLEX_WRAP       (1 << 6)
-#define LV_FLEX_REVERSE    (1 << 7)
+#define LV_FLEX_WRAP       (1 << 2)
+#define LV_FLEX_REVERSE    (1 << 3)
 
 /**********************
  *      TYPEDEFS
@@ -44,13 +44,20 @@ typedef enum {
     LV_FLEX_DIR_NONE,
     LV_FLEX_DIR_ROW,
     LV_FLEX_DIR_COLUMN,
-} lv_flex_dir_t;
+}lv_flex_dir_t;
+
+typedef struct {
+    lv_coord_t gap;
+    uint32_t place      :4;
+    uint32_t dir        :4;
+}lv_flex_cont_t;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
 void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place);
+void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap);
 void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
 void _lv_flex_refresh(lv_obj_t * cont);
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index c9a05d116..eca9d57cd 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1140,7 +1140,7 @@ lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child)
 }
 
 /**
- * Get the Nth child of a an object. 0th is the lastly created.
+ * Get the Nth child of an object. 0th is the lastly created.
  * @param obj pointer to an object whose children should be get
  * @param id of a child
  * @return the child or `NULL` if `id` was greater then the `number of children - 1`
@@ -1149,14 +1149,39 @@ lv_obj_t * lv_obj_get_child_by_id(const lv_obj_t * obj, uint32_t id)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    lv_obj_t * child = lv_obj_get_child_back(obj, NULL);
     uint32_t i;
     for(i = 0; i < id; i++) {
-        child = lv_obj_get_child(obj, child);
+        child = lv_obj_get_child_back(obj, child);
     }
 
     return child;
 }
+
+/**
+ * Get the child index of an object.
+ * If this object is the firstly created child of its parent 0 will be return.
+ * If its the second child return 1, etc.
+ * @param obj pointer to an object whose index should be get
+ * @return the child index of the object.
+ */
+uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    if(parent == NULL) return 0;
+
+    uint32_t id = 0;
+    lv_obj_t * child = lv_obj_get_child_back(parent, NULL);
+    while(child) {
+        if(child == obj) return id;
+        id++;
+        child = lv_obj_get_child_back(parent, child);
+    }
+    return id;
+}
+
 /**
  * Count the children of an object (only children directly on 'obj')
  * @param obj pointer to an object
@@ -1924,7 +1949,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
                 }
             }
             if(obj->grid) _lv_grid_full_refresh(obj);
-            if(obj->flex_dir) _lv_flex_refresh(obj);
+            if(obj->flex_cont.dir) _lv_flex_refresh(obj);
         }
     }
     else if(sign == LV_SIGNAL_CHILD_CHG) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 9ecd8562b..a986aa94d 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -256,10 +256,7 @@ struct _lv_obj_t {
 
     const lv_grid_t * grid;
 
-    uint8_t flex_dir   : 4;
-    uint8_t flex_place : 4;
-
-
+    lv_flex_cont_t flex_cont;
 };
 
 enum {
@@ -605,6 +602,15 @@ lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child);
  */
 lv_obj_t * lv_obj_get_child_by_id(const lv_obj_t * obj, uint32_t id);
 
+/**
+ * Get the child index of an object.
+ * If this object is the firstly created child of its parent 0 will be return.
+ * If its the second child return 1, etc.
+ * @param obj pointer to an object whose index should be get
+ * @return the child index of the object.
+ */
+uint32_t lv_obj_get_child_id(const lv_obj_t * obj);
+
 /**
  * Count the children of an object (only children directly on 'obj')
  * @param obj pointer to an object
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 2d843eda6..125f65fe4 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -732,7 +732,7 @@ bool _lv_obj_is_flex_item(struct _lv_obj_t * obj)
 {
     lv_obj_t * cont = lv_obj_get_parent(obj);
     if(cont == NULL) return false;
-    if(cont->flex_dir == LV_FLEX_DIR_NONE) return false;
+    if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return false;
     if(LV_COORD_IS_FLEX(obj->x_set) == false || LV_COORD_IS_FLEX(obj->y_set) == false) return false;
     return true;
 }
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 80a8f1fce..c3b9a3976 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -207,9 +207,6 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
     self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
     self_h += obj->scroll.y;
     return LV_MATH_MAX(child_res, self_h);
-
-
-    return child_res - obj->coords.y2 + lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
 }
 
 /**
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 8f3f09834..31ad91d04 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -48,8 +48,8 @@
 
 #define COLOR_BG_BORDER         (IS_LIGHT ? lv_color_hex(0xd6dde3) : lv_color_hex(0x808a97))   /*dfe7ed*/
 #define COLOR_BG_BORDER_PR      (IS_LIGHT ? lv_color_hex3(0xccc) : lv_color_hex(0x5f656e))
-#define COLOR_BG_BORDER_CHK     (IS_LIGHT ? lv_color_hex(0x3b3e42) : lv_color_hex(0x5f656e))
-#define COLOR_BG_BORDER_CHK_PR  (IS_LIGHT ? lv_color_hex(0x3b3e42) : lv_color_hex(0x5f656e))
+#define COLOR_BG_BORDER_CHK     (IS_LIGHT ? lv_color_hex(0xd6dde3) : lv_color_hex(0x5f656e))
+#define COLOR_BG_BORDER_CHK_PR  (IS_LIGHT ? lv_color_hex3(0xccc) : lv_color_hex(0x5f656e))
 #define COLOR_BG_BORDER_DIS     (IS_LIGHT ? lv_color_hex(0xd6dde3) : lv_color_hex(0x5f656e))
 
 #define COLOR_BG_TEXT           (IS_LIGHT ? lv_color_hex(0x3b3e42) : lv_color_hex(0xffffff))
@@ -64,7 +64,7 @@
 #define COLOR_BG_SEC_TEXT       (IS_LIGHT ? lv_color_hex(0x31404f) : lv_color_hex(0xa5a8ad))
 #define COLOR_BG_SEC_TEXT_DIS   (IS_LIGHT ? lv_color_hex(0xaaaaaa) : lv_color_hex(0xa5a8ad))
 
-#define TRANSITION_TIME         0/*((theme.flags & LV_THEME_MATERIAL_FLAG_NO_TRANSITION) ? 0 : 150)*/
+#define TRANSITION_TIME         ((theme.flags & LV_THEME_MATERIAL_FLAG_NO_TRANSITION) ? 0 : 150)
 #define BORDER_WIDTH            LV_DPX(2)
 #define OUTLINE_WIDTH           ((theme.flags & LV_THEME_MATERIAL_FLAG_NO_FOCUS) ? 0 : LV_DPX(2))
 #define IS_LIGHT (theme.flags & LV_THEME_MATERIAL_FLAG_LIGHT)
@@ -1006,6 +1006,11 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             _lv_style_list_add_style(list, &styles->btnmatrix_btn);
+
+            list = _lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN_2);
+            _lv_style_list_add_style(list, &styles->bg);
+            _lv_style_list_add_style(list, &styles->bg_click);
+            _lv_style_list_add_style(list, &styles->btnmatrix_btn);
             break;
 #endif
 
diff --git a/src/lv_widgets/lv_btnmatrix.c b/src/lv_widgets/lv_btnmatrix.c
index 03ea05ed4..10fe00b1f 100644
--- a/src/lv_widgets/lv_btnmatrix.c
+++ b/src/lv_widgets/lv_btnmatrix.c
@@ -101,6 +101,7 @@ lv_obj_t * lv_btnmatrix_create(lv_obj_t * par, const lv_obj_t * copy)
     lv_style_list_init(&ext->style_btn);
     lv_style_list_init(&ext->style_btn2);
     ext->style_btn.ignore_trans = 1;
+    ext->style_btn2.ignore_trans = 1;
 
     if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_cb(btnm);
 
diff --git a/src/lv_widgets/lv_calendar.c b/src/lv_widgets/lv_calendar.c
deleted file mode 100644
index 9aa6f3381..000000000
--- a/src/lv_widgets/lv_calendar.c
+++ /dev/null
@@ -1,1091 +0,0 @@
-/**
- * @file lv_calendar.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_calendar.h"
-#if LV_USE_CALENDAR != 0
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_hal/lv_hal_indev.h"
-#include "../lv_misc/lv_utils.h"
-#include "../lv_core/lv_indev.h"
-#include "../lv_themes/lv_theme.h"
-#include <string.h>
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_calendar"
-
-/**********************
- *      TYPEDEFS
- **********************/
-enum {
-    DAY_DRAW_PREV_MONTH,
-    DAY_DRAW_ACT_MONTH,
-    DAY_DRAW_NEXT_MONTH,
-};
-typedef uint8_t day_draw_state_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_design_res_t lv_calendar_design(lv_obj_t * calendar, const lv_area_t * clip_area, lv_design_mode_t mode);
-static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_calendar_get_style(lv_obj_t * calendar, uint8_t part);
-static bool calculate_touched_day(lv_obj_t * calendar, const lv_point_t * touched_point);
-static lv_coord_t get_header_height(lv_obj_t * calendar);
-static lv_coord_t get_day_names_height(lv_obj_t * calendar);
-static void draw_header(lv_obj_t * calendar, const lv_area_t * mask);
-static void draw_day_names(lv_obj_t * calendar, const lv_area_t * mask);
-static void draw_dates(lv_obj_t * calendar, const lv_area_t * clip_area);
-static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day);
-static bool is_highlighted(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day);
-static bool is_pressed(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day);
-static const char * get_day_name(lv_obj_t * calendar, uint8_t day);
-static const char * get_month_name(lv_obj_t * calendar, int32_t month);
-static uint8_t get_month_length(int32_t year, int32_t month);
-static uint8_t is_leap_year(uint32_t year);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_signal_cb_t ancestor_signal;
-static lv_design_cb_t ancestor_design;
-#if LV_CALENDAR_WEEK_STARTS_MONDAY != 0
-static const char * day_name[7]    = {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"};
-#else
-static const char * day_name[7]    = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
-#endif
-static const char * month_name[12] = {"January", "February", "March",     "April",   "May",      "June",
-                                      "July",    "August",   "September", "October", "November", "December"
-                                     };
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a calendar object
- * @param par pointer to an object, it will be the parent of the new calendar
- * @param copy pointer to a calendar object, if not NULL then the new object will be copied from it
- * @return pointer to the created calendar
- */
-lv_obj_t * lv_calendar_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-    LV_LOG_TRACE("calendar create started");
-
-    /*Create the ancestor of calendar*/
-    lv_obj_t * calendar = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(calendar);
-    if(calendar == NULL) return NULL;
-
-    /*Allocate the calendar type specific extended data*/
-    lv_calendar_ext_t * ext = lv_obj_allocate_ext_attr(calendar, sizeof(lv_calendar_ext_t));
-    LV_ASSERT_MEM(ext);
-    if(ext == NULL) {
-        lv_obj_del(calendar);
-        return NULL;
-    }
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(calendar);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(calendar);
-
-    /*Initialize the allocated 'ext' */
-    ext->today.year  = 2020;
-    ext->today.month = 1;
-    ext->today.day   = 1;
-
-    ext->showed_date.year  = 2020;
-    ext->showed_date.month = 1;
-    ext->showed_date.day   = 1;
-
-    ext->pressed_date.year  = 0;
-    ext->pressed_date.month = 0;
-    ext->pressed_date.day   = 0;
-
-    ext->highlighted_dates      = NULL;
-    ext->highlighted_dates_num  = 0;
-    ext->day_names              = NULL;
-    ext->month_names            = NULL;
-
-    ext->btn_pressing = 0;
-
-
-    lv_style_list_init(&ext->style_date_nums);
-    lv_style_list_init(&ext->style_day_names);
-    lv_style_list_init(&ext->style_header);
-    ext->style_date_nums.skip_trans = 1;
-    ext->style_day_names.skip_trans = 1;
-    ext->style_header.skip_trans = 1;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_cb(calendar, lv_calendar_signal);
-    lv_obj_set_design_cb(calendar, lv_calendar_design);
-
-    /*Init the new calendar calendar*/
-    if(copy == NULL) {
-        lv_theme_apply(calendar, LV_THEME_CALENDAR);
-
-        lv_obj_set_size(calendar, 5 * LV_DPI / 2, 5 * LV_DPI / 2);
-
-    }
-    /*Copy an existing calendar*/
-    else {
-        lv_calendar_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->today.year              = copy_ext->today.year;
-        ext->today.month             = copy_ext->today.month;
-        ext->today.day               = copy_ext->today.day;
-
-        ext->showed_date.year  = copy_ext->showed_date.year;
-        ext->showed_date.month = copy_ext->showed_date.month;
-        ext->showed_date.day   = copy_ext->showed_date.day;
-
-        ext->highlighted_dates     = copy_ext->highlighted_dates;
-        ext->highlighted_dates_num = copy_ext->highlighted_dates_num;
-        ext->day_names             = copy_ext->day_names;
-
-        ext->month_names            = copy_ext->month_names;
-        ext->style_header           = copy_ext->style_header;
-        ext->style_day_names        = copy_ext->style_day_names;
-        /*Refresh the style with new signal function*/
-        //        lv_obj_refresh_style(new_calendar);
-    }
-
-    LV_LOG_INFO("calendar created");
-
-    return calendar;
-}
-
-/*======================
- * Add/remove functions
- *=====================*/
-
-/*
- * New object specific "add" or "remove" functions come here
- */
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the today's date
- * @param calendar pointer to a calendar object
- * @param today pointer to an `lv_calendar_date_t` variable containing the date of today. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_today_date(lv_obj_t * calendar, lv_calendar_date_t * today)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(today);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->today.year         = today->year;
-    ext->today.month        = today->month;
-    ext->today.day          = today->day;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the currently showed
- * @param calendar pointer to a calendar object
- * @param showed pointer to an `lv_calendar_date_t` variable containing the date to show. The value
- * will be saved it can be local variable too.
- */
-void lv_calendar_set_showed_date(lv_obj_t * calendar, lv_calendar_date_t * showed)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(showed);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->showed_date.year   = showed->year;
-    ext->showed_date.month  = showed->month;
-    ext->showed_date.day    = showed->day;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the the highlighted dates
- * @param calendar pointer to a calendar object
- * @param highlighted pointer to an `lv_calendar_date_t` array containing the dates. ONLY A POINTER
- * WILL BE SAVED! CAN'T BE LOCAL ARRAY.
- * @param date_num number of dates in the array
- */
-void lv_calendar_set_highlighted_dates(lv_obj_t * calendar, lv_calendar_date_t highlighted[], uint16_t date_num)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(highlighted);
-
-    lv_calendar_ext_t * ext    = lv_obj_get_ext_attr(calendar);
-    ext->highlighted_dates     = highlighted;
-    ext->highlighted_dates_num = date_num;
-
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the name of the days
- * @param calendar pointer to a calendar object
- * @param day_names pointer to an array with the names. E.g. `const char * days[7] = {"Sun", "Mon",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(day_names);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->day_names          = day_names;
-    lv_obj_invalidate(calendar);
-}
-
-/**
- * Set the name of the month
- * @param calendar pointer to a calendar object
- * @param month_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
- * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
- * later.
- */
-void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** month_names)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-    LV_ASSERT_NULL(month_names);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->month_names        = month_names;
-    lv_obj_invalidate(calendar);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the today's date
- * @param calendar pointer to a calendar object
- * @return return pointer to an `lv_calendar_date_t` variable containing the date of today.
- */
-lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return &ext->today;
-}
-
-/**
- * Get the currently showed
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the date is being shown.
- */
-lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return &ext->showed_date;
-}
-
-/**
- * Get the the pressed date.
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the pressed date.
- * `NULL` if not date pressed (e.g. the header)
- */
-lv_calendar_date_t * lv_calendar_get_pressed_date(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->pressed_date.year != 0 ? &ext->pressed_date : NULL;
-}
-
-/**
- * Get the the highlighted dates
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` array containing the dates.
- */
-lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->highlighted_dates;
-}
-
-/**
- * Get the number of the highlighted dates
- * @param calendar pointer to a calendar object
- * @return number of highlighted days
- */
-uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->highlighted_dates_num;
-}
-
-/**
- * Get the name of the days
- * @param calendar pointer to a calendar object
- * @return pointer to the array of day names
- */
-const char ** lv_calendar_get_day_names(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->day_names;
-}
-
-/**
- * Get the name of the month
- * @param calendar pointer to a calendar object
- * @return pointer to the array of month names
- */
-const char ** lv_calendar_get_month_names(const lv_obj_t * calendar)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    return ext->month_names;
-}
-
-/*=====================
- * Other functions
- *====================*/
-
-/*
- * New object specific "other" functions come here
- */
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the calendars
- * @param calendar pointer to an object
- * @param clip_area the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return an element of `lv_design_res_t`
- */
-static lv_design_res_t lv_calendar_design(lv_obj_t * calendar, const lv_area_t * clip_area, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_design(calendar, clip_area, mode);
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_design(calendar, clip_area, mode);
-
-        draw_header(calendar, clip_area);
-        draw_day_names(calendar, clip_area);
-        draw_dates(calendar, clip_area);
-
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design(calendar, clip_area, mode);
-    }
-
-    return LV_DESIGN_RES_OK;
-}
-
-/**
- * Signal function of the calendar
- * @param calendar pointer to a calendar object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void * param)
-{
-    lv_res_t res;
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_calendar_get_style(calendar, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(calendar, sign, param);
-        return LV_RES_OK;
-    }
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(calendar, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_CLEANUP) {
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_HEADER);
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_DAY_NAMES);
-        lv_obj_clean_style_list(calendar, LV_CALENDAR_PART_DATE);
-    }
-    else if(sign == LV_SIGNAL_PRESSING) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        lv_area_t header_area;
-        lv_area_copy(&header_area, &calendar->coords);
-        header_area.y2 = header_area.y1 + get_header_height(calendar);
-
-        lv_indev_t * indev = lv_indev_get_act();
-        lv_point_t p;
-        lv_indev_get_point(indev, &p);
-
-        /*If the header is pressed mark an arrow as pressed*/
-        if(_lv_area_is_point_on(&header_area, &p, 0)) {
-            if(p.x < header_area.x1 + lv_area_get_width(&header_area) / 2) {
-                if(ext->btn_pressing != -1) lv_obj_invalidate(calendar);
-                ext->btn_pressing = -1;
-            }
-            else {
-                if(ext->btn_pressing != 1) lv_obj_invalidate(calendar);
-                ext->btn_pressing = 1;
-            }
-
-            ext->pressed_date.year  = 0;
-            ext->pressed_date.month = 0;
-            ext->pressed_date.day   = 0;
-        }
-        /*If a day is pressed save it*/
-        else if(calculate_touched_day(calendar, &p)) {
-            ext->btn_pressing = 0;
-            lv_obj_invalidate(calendar);
-        }
-        /*Else set a default state*/
-        else {
-            if(ext->btn_pressing != 0) lv_obj_invalidate(calendar);
-            ext->btn_pressing       = 0;
-            ext->pressed_date.year  = 0;
-            ext->pressed_date.month = 0;
-            ext->pressed_date.day   = 0;
-        }
-    }
-    else if(sign == LV_SIGNAL_PRESS_LOST) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        ext->btn_pressing       = 0;
-        ext->pressed_date.year  = 0;
-        ext->pressed_date.month = 0;
-        ext->pressed_date.day   = 0;
-        lv_obj_invalidate(calendar);
-
-    }
-    else if(sign == LV_SIGNAL_RELEASED) {
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(ext->btn_pressing < 0) {
-            if(ext->showed_date.month <= 1) {
-                ext->showed_date.month = 12;
-                ext->showed_date.year--;
-            }
-            else {
-                ext->showed_date.month--;
-            }
-        }
-        else if(ext->btn_pressing > 0) {
-            if(ext->showed_date.month >= 12) {
-                ext->showed_date.month = 1;
-                ext->showed_date.year++;
-            }
-            else {
-                ext->showed_date.month++;
-            }
-        }
-        else if(ext->pressed_date.year != 0) {
-            res = lv_event_send(calendar, LV_EVENT_VALUE_CHANGED, NULL);
-            if(res != LV_RES_OK) return res;
-
-        }
-
-        ext->btn_pressing = 0;
-        ext->pressed_date.year  = 0;
-        ext->pressed_date.month = 0;
-        ext->pressed_date.day   = 0;
-        lv_obj_invalidate(calendar);
-    }
-    else if(sign == LV_SIGNAL_CONTROL) {
-#if LV_USE_GROUP
-        uint8_t c               = *((uint8_t *)param);
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
-            if(ext->showed_date.month >= 12) {
-                ext->showed_date.month = 1;
-                ext->showed_date.year++;
-            }
-            else {
-                ext->showed_date.month++;
-            }
-            lv_obj_invalidate(calendar);
-        }
-        else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) {
-            if(ext->showed_date.month <= 1) {
-                ext->showed_date.month = 12;
-                ext->showed_date.year--;
-            }
-            else {
-                ext->showed_date.month--;
-            }
-            lv_obj_invalidate(calendar);
-        }
-#endif
-    }
-
-    return res;
-}
-
-/**
- * Get the style descriptor of a part of the object
- * @param page pointer the object
- * @param part the part from `lv_calendar_part_t`. (LV_CALENDAR_PART_...)
- * @return pointer to the style descriptor of the specified part
- */
-static lv_style_list_t * lv_calendar_get_style(lv_obj_t * calendar, uint8_t part)
-{
-    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    lv_style_list_t * style_dsc_p;
-
-
-    switch(part) {
-        case LV_CALENDAR_PART_BG:
-            style_dsc_p = &calendar->style_list;
-            break;
-        case LV_CALENDAR_PART_HEADER:
-            style_dsc_p = &ext->style_header;
-            break;
-        case LV_CALENDAR_PART_DAY_NAMES:
-            style_dsc_p = &ext->style_day_names;
-            break;
-        case LV_CALENDAR_PART_DATE:
-            style_dsc_p = &ext->style_date_nums;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * It will check if the days part of calendar is touched
- * and if it is, it will calculate the day and put it in pressed_date of calendar object.
- * @param calendar pointer to a calendar object
- * @param pointer to a point
- * @return true: days part of calendar is touched and its related date is put in pressed date
- * false: the point is out of days part area.
- */
-static bool calculate_touched_day(lv_obj_t * calendar, const lv_point_t * touched_point)
-{
-    lv_area_t days_area;
-    lv_area_copy(&days_area, &calendar->coords);
-    lv_style_int_t left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-
-    days_area.x1 += left;
-    days_area.x2 -= right;
-    days_area.y1 = calendar->coords.y1 + get_header_height(calendar) + get_day_names_height(calendar) + top;
-    days_area.y2 -= bottom;
-
-    if(_lv_area_is_point_on(&days_area, touched_point, 0)) {
-        lv_coord_t w  = (days_area.x2 - days_area.x1 + 1) / 7;
-        lv_coord_t h  = (days_area.y2 - days_area.y1 + 1) / 6;
-        uint8_t x_pos = 0;
-        x_pos         = (touched_point->x - days_area.x1) / w;
-        if(x_pos > 6) x_pos = 6;
-        uint8_t y_pos = 0;
-        y_pos         = (touched_point->y - days_area.y1) / h;
-        if(y_pos > 5) y_pos = 5;
-
-        uint8_t i_pos           = 0;
-        i_pos                   = (y_pos * 7) + x_pos;
-        lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-        if(i_pos < get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1)) {
-            ext->pressed_date.year  = ext->showed_date.year - (ext->showed_date.month == 1 ? 1 : 0);
-            ext->pressed_date.month = ext->showed_date.month == 1 ? 12 : (ext->showed_date.month - 1);
-            ext->pressed_date.day   = get_month_length(ext->pressed_date.year, ext->pressed_date.month) -
-                                      get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) + 1 + i_pos;
-        }
-        else if(i_pos < (get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) +
-                         get_month_length(ext->showed_date.year, ext->showed_date.month))) {
-            ext->pressed_date.year  = ext->showed_date.year;
-            ext->pressed_date.month = ext->showed_date.month;
-            ext->pressed_date.day   = i_pos + 1 - get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1);
-        }
-        else if(i_pos < 42) {
-            ext->pressed_date.year  = ext->showed_date.year + (ext->showed_date.month == 12 ? 1 : 0);
-            ext->pressed_date.month = ext->showed_date.month == 12 ? 1 : (ext->showed_date.month + 1);
-            ext->pressed_date.day   = i_pos + 1 - get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1) -
-                                      get_month_length(ext->showed_date.year, ext->showed_date.month);
-        }
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-
-/**
- * Get the height of a calendar's header based on it's style
- * @param calendar point to a calendar
- * @return the header's height
- */
-static lv_coord_t get_header_height(lv_obj_t * calendar)
-{
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t top = lv_obj_get_style_margin_top(calendar, LV_CALENDAR_PART_HEADER) +
-                         lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t bottom = lv_obj_get_style_margin_bottom(calendar, LV_CALENDAR_PART_HEADER) +
-                            lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_HEADER);
-
-    return lv_font_get_line_height(font) + top + bottom;
-}
-
-/**
- * Get the height of a calendar's day_names based on it's style
- * @param calendar point to a calendar
- * @return the day_names's height
- */
-static lv_coord_t get_day_names_height(lv_obj_t * calendar)
-{
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DAY_NAMES);
-
-    return lv_font_get_line_height(font) + top + bottom;
-}
-
-/**
- * Draw the calendar header with month name and arrows
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_header(lv_obj_t * calendar, const lv_area_t * mask)
-{
-    lv_style_int_t header_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_HEADER);
-    lv_style_int_t header_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_HEADER);
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_HEADER);
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-    lv_area_t header_area;
-    header_area.x1 = calendar->coords.x1;
-    header_area.x2 = calendar->coords.x2;
-    header_area.y1 = calendar->coords.y1 + lv_obj_get_style_margin_top(calendar, LV_CALENDAR_PART_HEADER);
-    header_area.y2 = header_area.y1 + lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_HEADER) +
-                     lv_font_get_line_height(font) + lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_HEADER);
-
-    lv_draw_rect_dsc_t header_rect_dsc;
-    lv_draw_rect_dsc_init(&header_rect_dsc);
-    lv_obj_init_draw_rect_dsc(calendar, LV_CALENDAR_PART_HEADER, &header_rect_dsc);
-    lv_draw_rect(&header_area, mask, &header_rect_dsc);
-
-    lv_state_t state_ori = calendar->state;
-
-    /*Add the year + month name*/
-    char txt_buf[64];
-    _lv_utils_num_to_str(ext->showed_date.year, txt_buf);
-    txt_buf[4] = ' ';
-    txt_buf[5] = '\0';
-    strcpy(&txt_buf[5], get_month_name(calendar, ext->showed_date.month));
-
-    calendar->state = LV_STATE_DEFAULT;
-    _lv_obj_disable_style_caching(calendar, true);
-
-    lv_draw_label_dsc_t label_dsc;
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    label_dsc.flag = LV_TXT_FLAG_CENTER;
-    header_area.y1 += lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_HEADER);
-    header_area.y2 -= lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_HEADER);
-    lv_draw_label(&header_area, mask, &label_dsc, txt_buf, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-
-    /*Add the left arrow*/
-    if(ext->btn_pressing < 0) calendar->state |= LV_STATE_PRESSED;
-    else calendar->state &= ~(LV_STATE_PRESSED);
-
-    header_area.x1 += header_left;
-
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    lv_draw_label(&header_area, mask, &label_dsc, LV_SYMBOL_LEFT, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-
-    /*Add the right arrow*/
-    if(ext->btn_pressing > 0) calendar->state |= LV_STATE_PRESSED;
-    else calendar->state &= ~(LV_STATE_PRESSED);
-
-    header_area.x1 = header_area.x2 - header_right - _lv_txt_get_width(LV_SYMBOL_RIGHT, (uint16_t)strlen(LV_SYMBOL_RIGHT),
-                                                                       font, 0, LV_TXT_FLAG_NONE);
-
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_HEADER, &label_dsc);
-    lv_draw_label(&header_area, mask, &label_dsc, LV_SYMBOL_RIGHT, NULL);
-
-    calendar->state = state_ori;    /*Restore the state*/
-    _lv_obj_disable_style_caching(calendar, false);
-}
-
-/**
- * Draw the day's name below the header
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_day_names(lv_obj_t * calendar, const lv_area_t * mask)
-{
-    lv_style_int_t date_top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_inner = lv_obj_get_style_pad_inner(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_coord_t days_w      = lv_obj_get_width(calendar) - date_left - date_right;
-    lv_coord_t box_w      = (days_w - date_inner * 6) / 7;
-    lv_coord_t days_y1 = calendar->coords.y1 + date_top + get_header_height(calendar) + get_day_names_height(calendar);
-    lv_coord_t days_h = calendar->coords.y2 - days_y1 - date_bottom;
-    lv_coord_t box_h      = (days_h - 5 * date_inner) / 6;
-    lv_coord_t box_size = LV_MATH_MIN(box_w, box_h);
-
-    lv_style_int_t left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    lv_style_int_t top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DAY_NAMES);
-    const lv_font_t * font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DAY_NAMES);
-
-    lv_coord_t w = lv_obj_get_width(calendar) - left - right;
-
-    lv_coord_t label_w = w / 6;
-
-    lv_area_t label_area;
-    label_area.y1 = calendar->coords.y1 + get_header_height(calendar) + top;
-    label_area.y2 = label_area.y1 + lv_font_get_line_height(font);
-
-    lv_draw_label_dsc_t label_dsc;
-    lv_draw_label_dsc_init(&label_dsc);
-    lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_DAY_NAMES, &label_dsc);
-    label_dsc.flag = LV_TXT_FLAG_CENTER;
-
-    uint32_t i;
-    for(i = 0; i < 7; i++) {
-        label_area.x1 = calendar->coords.x1 + ((w - box_size) * i) / 6  + box_size / 2 - label_w / 2 + left;
-        label_area.x2 = label_area.x1 + label_w - 1;
-
-        lv_draw_label(&label_area, mask, &label_dsc, get_day_name(calendar, i), NULL);
-    }
-}
-
-/**
- * Draw the date numbers in a matrix
- * @param calendar point to a calendar
- * @param mask a mask for drawing
- */
-static void draw_dates(lv_obj_t * calendar, const lv_area_t * clip_area)
-{
-    lv_calendar_ext_t * ext     = lv_obj_get_ext_attr(calendar);
-
-    const lv_font_t * nums_font = lv_obj_get_style_text_font(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_style_int_t date_top = lv_obj_get_style_pad_top(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_bottom = lv_obj_get_style_pad_bottom(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_left = lv_obj_get_style_pad_left(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_right = lv_obj_get_style_pad_right(calendar, LV_CALENDAR_PART_DATE);
-    lv_style_int_t date_inner = lv_obj_get_style_pad_inner(calendar, LV_CALENDAR_PART_DATE);
-
-    lv_coord_t days_y1 = calendar->coords.y1 + date_top + get_header_height(calendar) + get_day_names_height(calendar);
-    lv_coord_t days_h = calendar->coords.y2 - days_y1 - date_bottom;
-
-    /*The state changes without re-caching the styles, disable the use of cache*/
-    lv_state_t state_ori = calendar->state;
-    calendar->state = LV_STATE_DEFAULT;
-    _lv_obj_disable_style_caching(calendar, true);
-
-    lv_state_t month_state = LV_STATE_DISABLED;
-
-    uint8_t day_cnt;
-    lv_coord_t days_w      = lv_obj_get_width(calendar) - date_left - date_right;
-    lv_coord_t box_w      = (days_w - date_inner * 6) / 7;
-    lv_coord_t box_h      = (days_h - 5 * date_inner) / 6;
-    lv_coord_t box_size = LV_MATH_MIN(box_w, box_h);
-
-    uint8_t month_start_day = get_day_of_week(ext->showed_date.year, ext->showed_date.month, 1);
-
-    day_draw_state_t draw_state;
-
-    /*If starting with the first day of the week then the previous month is not visible*/
-    if(month_start_day == 0) {
-        day_cnt    = 1;
-        draw_state = DAY_DRAW_ACT_MONTH;
-        month_state  = 0;
-    }
-    else {
-        draw_state = DAY_DRAW_PREV_MONTH;
-        day_cnt = get_month_length(ext->showed_date.year, ext->showed_date.month - 1); /*Length of the previous month*/
-        day_cnt -= month_start_day - 1; /*First visible number of the previous month*/
-        month_state = LV_STATE_DISABLED;
-    }
-
-    bool month_of_today_shown = false;
-    if(ext->showed_date.year == ext->today.year && ext->showed_date.month == ext->today.month) {
-        month_of_today_shown = true;
-    }
-
-    char buf[3];
-
-    /*Draw 6 weeks*/
-    lv_draw_rect_dsc_t rect_dsc;
-    lv_draw_label_dsc_t label_dsc;
-    lv_state_t prev_state = 0xFF;
-    uint32_t week;
-    for(week = 0; week < 6; week++) {
-        lv_area_t box_area;
-
-        box_area.y1 = days_y1 + ((days_h - box_size) * week) / 5;
-        box_area.y2 = box_area.y1 + box_size - 1;
-
-        if(box_area.y1 > clip_area->y2) {
-            calendar->state = state_ori;
-            _lv_obj_disable_style_caching(calendar, false);
-            return;
-        }
-
-        lv_area_t label_area;
-        label_area.y1 = box_area.y1 + (lv_area_get_height(&box_area) - lv_font_get_line_height(nums_font)) / 2;
-        label_area.y2 = label_area.y1 + lv_font_get_line_height(nums_font);
-
-        /*Draw the 7 days of a week*/
-        uint32_t day;
-        for(day = 0; day < 7; day++) {
-            /*The previous month is over*/
-            if(draw_state == DAY_DRAW_PREV_MONTH && day == month_start_day) {
-                draw_state = DAY_DRAW_ACT_MONTH;
-                day_cnt    = 1;
-                month_state  = 0;
-            }
-            /*The current month is over*/
-            else if(draw_state == DAY_DRAW_ACT_MONTH &&
-                    day_cnt > get_month_length(ext->showed_date.year, ext->showed_date.month)) {
-                draw_state = DAY_DRAW_NEXT_MONTH;
-                day_cnt    = 1;
-                month_state  = LV_STATE_DISABLED;
-            }
-
-            if(box_area.y2 < clip_area->y1) {
-                day_cnt++;
-                continue;
-            }
-
-            lv_state_t day_state = month_state;
-            if(is_pressed(calendar, draw_state, ext->showed_date.year, ext->showed_date.month, day_cnt)) {
-                day_state |= LV_STATE_PRESSED;
-            }
-            if(is_highlighted(calendar, draw_state, ext->showed_date.year, ext->showed_date.month, day_cnt)) {
-                day_state |= LV_STATE_CHECKED;
-            }
-            if(month_of_today_shown && day_cnt == ext->today.day && draw_state == DAY_DRAW_ACT_MONTH) {
-                day_state |= LV_STATE_FOCUSED;
-            }
-
-            if(prev_state != day_state) {
-                lv_draw_rect_dsc_init(&rect_dsc);
-                lv_draw_label_dsc_init(&label_dsc);
-                label_dsc.flag = LV_TXT_FLAG_CENTER;
-
-                calendar->state = day_state;
-                lv_obj_init_draw_label_dsc(calendar, LV_CALENDAR_PART_DATE, &label_dsc);
-                lv_obj_init_draw_rect_dsc(calendar, LV_CALENDAR_PART_DATE, &rect_dsc);
-
-                prev_state = day_state;
-            }
-
-            label_area.x1 = calendar->coords.x1 + ((days_w - box_size) * day) / 6 + date_left;
-            label_area.x2 = label_area.x1 + box_size - 1;
-
-            box_area.x1 = label_area.x1;
-            box_area.x2 = label_area.x2;
-
-
-            lv_draw_rect(&box_area, clip_area, &rect_dsc);
-
-            /*Write the day's number*/
-            _lv_utils_num_to_str(day_cnt, buf);
-            lv_draw_label(&label_area, clip_area, &label_dsc, buf, NULL);
-
-            /*Go to the next day*/
-            day_cnt++;
-        }
-    }
-    calendar->state = state_ori;
-    _lv_obj_disable_style_caching(calendar, false);
-
-
-}
-
-/**
- * Check weather a date is highlighted or not
- * @param calendar pointer to a calendar object
- * @param draw_state which month is drawn (previous, active, next)
- * @param year a year
- * @param month a  month [1..12]
- * @param day a day [1..31]
- * @return true: highlighted
- */
-static bool is_highlighted(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day)
-{
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-
-    if(draw_state == DAY_DRAW_PREV_MONTH) {
-        year -= month == 1 ? 1 : 0;
-        month = month == 1 ? 12 : month - 1;
-    }
-    else if(draw_state == DAY_DRAW_NEXT_MONTH) {
-        year += month == 12 ? 1 : 0;
-        month = month == 12 ? 1 : month + 1;
-    }
-
-    uint32_t i;
-    for(i = 0; i < ext->highlighted_dates_num; i++) {
-        if(ext->highlighted_dates[i].year == year && ext->highlighted_dates[i].month == month &&
-           ext->highlighted_dates[i].day == day) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Check weather a date is highlighted or not
- * @param calendar pointer to a calendar object
- * @param draw_state which month is drawn (previous, active, next)
- * @param year a year
- * @param month a  month [1..12]
- * @param day a day [1..31]
- * @return true: highlighted
- */
-static bool is_pressed(lv_obj_t * calendar, day_draw_state_t draw_state, int32_t year, int32_t month, int32_t day)
-{
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-
-
-    if(draw_state == DAY_DRAW_PREV_MONTH) {
-        year -= month == 1 ? 1 : 0;
-        month = month == 1 ? 12 : month - 1;
-    }
-    else if(draw_state == DAY_DRAW_NEXT_MONTH) {
-        year += month == 12 ? 1 : 0;
-        month = month == 12 ? 1 : month + 1;
-    }
-
-    if(year == ext->pressed_date.year && month == ext->pressed_date.month && day == ext->pressed_date.day) return true;
-    else return false;
-}
-/**
- * Get the day name
- * @param calendar pointer to a calendar object
- * @param day a day in [0..6]
- * @return
- */
-static const char * get_day_name(lv_obj_t * calendar, uint8_t day)
-{
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    if(ext->day_names)
-        return ext->day_names[day];
-    else
-        return day_name[day];
-}
-
-/**
- * Get the month name
- * @param calendar pointer to a calendar object
- * @param month a month. The range is basically [1..12] but [-11..1] is also supported to handle
- * previous year
- * @return
- */
-static const char * get_month_name(lv_obj_t * calendar, int32_t month)
-{
-    month--; /*Range of months id [1..12] but range of indexes is [0..11]*/
-    if(month < 0) month = 12 + month;
-
-    lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    if(ext->month_names)
-        return ext->month_names[month];
-    else
-        return month_name[month];
-}
-
-/**
- * Get the number of days in a month
- * @param year a year
- * @param month a month. The range is basically [1..12] but [-11..1] is also supported to handle
- * previous year
- * @return [28..31]
- */
-static uint8_t get_month_length(int32_t year, int32_t month)
-{
-    month--; /*Range of months id [1..12] but range of indexes is [0..11]*/
-    if(month < 0) {
-        year--;             /*Already in the previous year (won't be less then -12 to skip a whole year)*/
-        month = 12 + month; /*`month` is negative, the result will be < 12*/
-    }
-    if(month >= 12) {
-        year++;
-        month -= 12;
-    }
-
-    /*month == 1 is february*/
-    return (month == 1) ? (28 + is_leap_year(year)) : 31 - month % 7 % 2;
-}
-
-/**
- * Tells whether a year is leap year or not
- * @param year a year
- * @return 0: not leap year; 1: leap year
- */
-static uint8_t is_leap_year(uint32_t year)
-{
-    return (year % 4) || ((year % 100 == 0) && (year % 400)) ? 0 : 1;
-}
-
-/**
- * Get the day of the week
- * @param year a year
- * @param month a  month
- * @param day a day
- * @return [0..6] which means [Sun..Sat] or [Mon..Sun] depending on LV_CALENDAR_WEEK_STARTS_MONDAY
- */
-static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day)
-{
-    uint32_t a = month < 3 ? 1 : 0;
-    uint32_t b = year - a;
-
-#if LV_CALENDAR_WEEK_STARTS_MONDAY
-    uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400) - 1) % 7;
-#else
-    uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400)) % 7;
-#endif
-
-    return day_of_week;
-}
-
-#endif
diff --git a/src/lv_widgets/lv_cont.c b/src/lv_widgets/lv_cont.c
deleted file mode 100644
index 08a0e4e6f..000000000
--- a/src/lv_widgets/lv_cont.c
+++ /dev/null
@@ -1,805 +0,0 @@
-/**
- * @file lv_cont.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "lv_cont.h"
-#if LV_USE_CONT != 0
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "../lv_misc/lv_debug.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_draw/lv_draw_mask.h"
-#include "../lv_themes/lv_theme.h"
-#include "../lv_misc/lv_area.h"
-#include "../lv_misc/lv_color.h"
-#include "../lv_misc/lv_math.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_OBJX_NAME "lv_cont"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param);
-static lv_style_list_t * lv_cont_get_style(lv_obj_t * cont, uint8_t type);
-static void lv_cont_refr_layout(lv_obj_t * cont);
-static void lv_cont_layout_col(lv_obj_t * cont);
-static void lv_cont_layout_row(lv_obj_t * cont);
-static void lv_cont_layout_center(lv_obj_t * cont);
-static void lv_cont_layout_pretty(lv_obj_t * cont);
-static void lv_cont_layout_grid(lv_obj_t * cont);
-static void lv_cont_refr_autofit(lv_obj_t * cont);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_cb_t ancestor_design;
-static lv_signal_cb_t ancestor_signal;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a container objects
- * @param par pointer to an object, it will be the parent of the new container
- * @param copy pointer to a container object, if not NULL then the new object will be copied from it
- * @return pointer to the created container
- */
-lv_obj_t * lv_cont_create(lv_obj_t * par, const lv_obj_t * copy)
-{
-
-    LV_LOG_TRACE("container create started");
-
-    /*Create a basic object*/
-    lv_obj_t * cont = lv_obj_create(par, copy);
-    LV_ASSERT_MEM(cont);
-    if(cont == NULL) return NULL;
-
-    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(cont);
-    if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(cont);
-
-    lv_obj_allocate_ext_attr(cont, sizeof(lv_cont_ext_t));
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext == NULL) {
-        lv_obj_del(cont);
-        return NULL;
-    }
-
-    LV_ASSERT_MEM(ext);
-    ext->fit_left   = LV_FIT_NONE;
-    ext->fit_right  = LV_FIT_NONE;
-    ext->fit_top    = LV_FIT_NONE;
-    ext->fit_bottom = LV_FIT_NONE;
-    ext->layout     = LV_LAYOUT_OFF;
-
-    lv_obj_set_signal_cb(cont, lv_cont_signal);
-
-    /*Init the new container*/
-    if(copy == NULL) {
-        /*Set the default styles if it's not screen*/
-        if(par != NULL) {
-            lv_theme_apply(cont, LV_THEME_CONT);
-        }
-
-
-    }
-    /*Copy an existing object*/
-    else {
-        lv_cont_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        ext->fit_left            = copy_ext->fit_left;
-        ext->fit_right           = copy_ext->fit_right;
-        ext->fit_top             = copy_ext->fit_top;
-        ext->fit_bottom          = copy_ext->fit_bottom;
-        ext->layout              = copy_ext->layout;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refresh_style(cont, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
-    }
-
-    LV_LOG_INFO("container created");
-
-    return cont;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a layout on a container
- * @param cont pointer to a container object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext->layout == layout) return;
-
-    ext->layout = layout;
-
-    /*Send a signal to refresh the layout*/
-    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
-}
-
-/**
- * Set the fit policy in all 4 directions separately.
- * It tell how to change the container's size automatically.
- * @param cont pointer to a container object
- * @param left left fit policy from `lv_fit_t`
- * @param right right fit policy from `lv_fit_t`
- * @param top bottom fit policy from `lv_fit_t`
- * @param bottom bottom fit policy from `lv_fit_t`
- */
-void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_obj_invalidate(cont);
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    if(ext->fit_left == left && ext->fit_right == right && ext->fit_top == top && ext->fit_bottom == bottom) {
-        return;
-    }
-
-    ext->fit_left   = left;
-    ext->fit_right  = right;
-    ext->fit_top    = top;
-    ext->fit_bottom = bottom;
-
-    /*Send a signal to refresh the layout*/
-    cont->signal_cb(cont, LV_SIGNAL_CHILD_CHG, NULL);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the layout of a container
- * @param cont pointer to container object
- * @return the layout from 'lv_cont_layout_t'
- */
-lv_layout_t lv_cont_get_layout(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->layout;
-}
-
-/**
- * Get left fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_left(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_left;
-}
-
-/**
- * Get right fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_right(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_right;
-}
-
-/**
- * Get top fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_top(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_top;
-}
-
-/**
- * Get bottom fit mode of a container
- * @param cont pointer to a container object
- * @return an element of `lv_fit_t`
- */
-lv_fit_t lv_cont_get_fit_bottom(const lv_obj_t * cont)
-{
-    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
-
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-    return ext->fit_bottom;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Signal function of the container
- * @param cont pointer to a container object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
- */
-static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
-{
-    if(sign == LV_SIGNAL_GET_STYLE) {
-        lv_get_style_info_t * info = param;
-        info->result = lv_cont_get_style(cont, info->part);
-        if(info->result != NULL) return LV_RES_OK;
-        else return ancestor_signal(cont, sign, param);
-    }
-
-    lv_res_t res;
-
-    /* Include the ancient signal function */
-    res = ancestor_signal(cont, sign, param);
-    if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
-
-    if(sign == LV_SIGNAL_STYLE_CHG) { /*Recalculate the padding if the style changed*/
-        lv_cont_refr_layout(cont);
-        lv_cont_refr_autofit(cont);
-    }
-    else if(sign == LV_SIGNAL_CHILD_CHG) {
-        lv_cont_refr_layout(cont);
-        lv_cont_refr_autofit(cont);
-    }
-    else if(sign == LV_SIGNAL_COORD_CHG) {
-        if(lv_obj_get_width(cont) != lv_area_get_width(param) || lv_obj_get_height(cont) != lv_area_get_height(param)) {
-            lv_cont_refr_layout(cont);
-            lv_cont_refr_autofit(cont);
-        }
-    }
-    else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
-        /*MAX and EDGE fit needs to be refreshed if the parent's size has changed*/
-        lv_cont_refr_autofit(cont);
-    }
-
-    return res;
-}
-
-
-static lv_style_list_t * lv_cont_get_style(lv_obj_t * cont, uint8_t type)
-{
-    lv_style_list_t * style_dsc_p;
-    switch(type) {
-        case LV_CONT_PART_MAIN:
-            style_dsc_p = &cont->style_list;
-            break;
-        default:
-            style_dsc_p = NULL;
-    }
-
-    return style_dsc_p;
-}
-
-/**
- * Refresh the layout of a container
- * @param cont pointer to an object which layout should be refreshed
- */
-static void lv_cont_refr_layout(lv_obj_t * cont)
-{
-    if(lv_obj_is_protected(cont, LV_PROTECT_CHILD_CHG)) return;
-    lv_layout_t type = lv_cont_get_layout(cont);
-
-    /*'cont' has to be at least 1 child*/
-    if(lv_obj_get_child(cont, NULL) == NULL) return;
-
-    if(type == LV_LAYOUT_OFF) return;
-
-    if(type == LV_LAYOUT_CENTER) {
-        lv_cont_layout_center(cont);
-    }
-    else if(type == LV_LAYOUT_COLUMN_LEFT || type == LV_LAYOUT_COLUMN_MID || type == LV_LAYOUT_COLUMN_RIGHT) {
-        lv_cont_layout_col(cont);
-    }
-    else if(type == LV_LAYOUT_ROW_TOP || type == LV_LAYOUT_ROW_MID || type == LV_LAYOUT_ROW_BOTTOM) {
-        lv_cont_layout_row(cont);
-    }
-    else if(type == LV_LAYOUT_PRETTY_MID || type == LV_LAYOUT_PRETTY_TOP || type == LV_LAYOUT_PRETTY_BOTTOM) {
-        lv_cont_layout_pretty(cont);
-    }
-    else if(type == LV_LAYOUT_GRID) {
-        lv_cont_layout_grid(cont);
-    }
-}
-
-/**
- * Handle column type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_col(lv_obj_t * cont)
-{
-    lv_coord_t left = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t right = lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    lv_coord_t top = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    lv_layout_t type = lv_cont_get_layout(cont);
-    lv_obj_t * child;
-
-    /*Adjust margin and get the alignment type*/
-    lv_align_t align;
-    lv_coord_t hpad_corr;
-
-    switch(type) {
-        case LV_LAYOUT_COLUMN_LEFT:
-            hpad_corr = left;
-            align     = LV_ALIGN_IN_TOP_LEFT;
-            break;
-        case LV_LAYOUT_COLUMN_MID:
-            hpad_corr = 0;
-            align     = LV_ALIGN_IN_TOP_MID;
-            break;
-        case LV_LAYOUT_COLUMN_RIGHT:
-            hpad_corr = -right;
-            align     = LV_ALIGN_IN_TOP_RIGHT;
-            break;
-        default:
-            hpad_corr = 0;
-            align     = LV_ALIGN_IN_TOP_LEFT;
-            break;
-    }
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-    /* Align the children */
-    lv_coord_t last_cord = top;
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        lv_style_int_t mtop = lv_obj_get_style_margin_top(child, LV_OBJ_PART_MAIN);
-        lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN);
-        lv_style_int_t mleft = lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN);
-        lv_obj_align(child, cont, align, hpad_corr + mleft, last_cord + mtop);
-        last_cord += lv_obj_get_height(child) + inner + mtop + mbottom;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle row type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_row(lv_obj_t * cont)
-{
-
-    lv_layout_t type = lv_cont_get_layout(cont);
-    lv_obj_t * child;
-
-    /*Adjust margin and get the alignment type*/
-    lv_align_t align;
-    lv_coord_t vpad_corr;
-    lv_bidi_dir_t base_dir = lv_obj_get_base_dir(cont);
-    switch(type) {
-        case LV_LAYOUT_ROW_TOP:
-            vpad_corr = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_TOP_RIGHT : LV_ALIGN_IN_TOP_LEFT;
-            break;
-        case LV_LAYOUT_ROW_MID:
-            vpad_corr = 0;
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_RIGHT_MID : LV_ALIGN_IN_LEFT_MID;
-            break;
-        case LV_LAYOUT_ROW_BOTTOM:
-            vpad_corr = -lv_obj_get_style_pad_bottom(cont, LV_CONT_PART_MAIN);
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_BOTTOM_RIGHT : LV_ALIGN_IN_BOTTOM_LEFT;
-            break;
-        default:
-            vpad_corr = 0;
-            align     = base_dir == LV_BIDI_DIR_RTL ? LV_ALIGN_IN_TOP_RIGHT : LV_ALIGN_IN_TOP_LEFT;
-            break;
-    }
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t last_cord;
-    if(base_dir == LV_BIDI_DIR_RTL) last_cord = lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    else last_cord = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-        if(base_dir == LV_BIDI_DIR_RTL) lv_obj_align(child, cont, align, -last_cord, vpad_corr);
-        else lv_obj_align(child, cont, align, last_cord, vpad_corr);
-
-        last_cord += lv_obj_get_width(child) + inner;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the center layout
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_center(lv_obj_t * cont)
-{
-    lv_obj_t * child;
-    uint32_t obj_num         = 0;
-    lv_coord_t h_tot         = 0;
-
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-    _LV_LL_READ(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        h_tot += lv_obj_get_height(child) + inner;
-        obj_num++;
-    }
-
-    if(obj_num == 0) return;
-
-    h_tot -= inner;
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t last_cord = -(h_tot / 2);
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-        lv_obj_align(child, cont, LV_ALIGN_CENTER, 0, last_cord + lv_obj_get_height(child) / 2);
-        last_cord += lv_obj_get_height(child) + inner;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the pretty layout. Put as many object as possible in row
- * then begin a new row
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_pretty(lv_obj_t * cont)
-{
-    lv_layout_t type = lv_cont_get_layout(cont);
-
-    lv_obj_t * child_rs;  /* Row starter child */
-    lv_obj_t * child_rc;  /* Row closer child */
-    lv_obj_t * child_tmp; /* Temporary child */
-    lv_coord_t w_obj         = lv_obj_get_width(cont);
-    lv_coord_t act_y         =  lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-
-    child_rs = _lv_ll_get_tail(&cont->child_ll); /*Set the row starter child*/
-    if(child_rs == NULL) return;                /*Return if no child*/
-
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-    lv_coord_t pleft          =  lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t pright         =  lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-    lv_coord_t pinner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-
-    child_rc = child_rs; /*Initially the the row starter and closer is the same*/
-    while(child_rs != NULL) {
-        lv_coord_t h_row = 0;
-        lv_coord_t w_row = pleft + pright; /*The width is at least the left+right pad*/
-        uint32_t obj_num = 0;
-
-        /*Find the row closer object and collect some data*/
-        do {
-            if(lv_obj_get_hidden(child_rc) == false && lv_obj_is_protected(child_rc, LV_PROTECT_POS) == false) {
-                /*If this object is already not fit then break*/
-                lv_coord_t w = lv_obj_get_width(child_rc);
-                w += lv_obj_get_style_margin_left(child_rc, LV_OBJ_PART_MAIN);
-                w += lv_obj_get_style_margin_right(child_rc, LV_OBJ_PART_MAIN);
-                if(w_row + w > w_obj) {
-                    /*Step back one child because the last already not fit, so the previous is the
-                     * closer*/
-                    if(child_rc != NULL && obj_num != 0) {
-                        child_rc = _lv_ll_get_next(&cont->child_ll, child_rc);
-                    }
-                    break;
-                }
-                w_row += w + pinner; /*Add the object width + inner padding*/
-
-                lv_coord_t h = lv_obj_get_height(child_rc);
-                h += lv_obj_get_style_margin_top(child_rc, LV_OBJ_PART_MAIN);
-                h += lv_obj_get_style_margin_bottom(child_rc, LV_OBJ_PART_MAIN);
-                h_row = LV_MATH_MAX(h_row, h);         /*Search the highest object*/
-                obj_num++;
-                if(lv_obj_is_protected(child_rc, LV_PROTECT_FOLLOW))
-                    break; /*If can not be followed by an other object then break here*/
-            }
-            child_rc = _lv_ll_get_prev(&cont->child_ll, child_rc); /*Load the next object*/
-            if(obj_num == 0)
-                child_rs = child_rc; /*If the first object was hidden (or too long) then set the
-                                        next as first */
-        } while(child_rc != NULL);
-
-        /*If the object is too long then align it to the middle*/
-        if(obj_num == 0) {
-            if(child_rc != NULL) {
-                lv_style_int_t mtop = lv_obj_get_style_margin_top(child_rc, LV_OBJ_PART_MAIN);
-
-                lv_obj_align(child_rc, cont, LV_ALIGN_IN_TOP_MID, 0, act_y + mtop);
-                h_row = lv_obj_get_height(child_rc); /*Not set previously because of the early break*/
-                h_row += mtop;
-                h_row += lv_obj_get_style_margin_bottom(child_rc, LV_OBJ_PART_MAIN);
-            }
-        }
-        /*If there is only one object in the row then align it to the middle*/
-        else if(obj_num == 1) {
-            lv_obj_align(child_rs, cont, LV_ALIGN_IN_TOP_MID,
-                         0,
-                         act_y + lv_obj_get_style_margin_top(child_rs, LV_OBJ_PART_MAIN));
-        }
-        /* Align the children (from child_rs to child_rc)*/
-        else {
-            w_row -= pinner * obj_num;
-            lv_coord_t new_pinner = (w_obj - w_row) / (obj_num - 1);
-            lv_coord_t act_x    = pleft; /*x init*/
-            child_tmp           = child_rs;
-            lv_align_t align;
-            int32_t inv;
-            if(lv_obj_get_base_dir(cont) == LV_BIDI_DIR_RTL) {
-                align = LV_ALIGN_IN_TOP_RIGHT;
-                inv = -1;
-            }
-            else {
-                align = LV_ALIGN_IN_TOP_LEFT;
-                inv = 1;
-            }
-            while(child_tmp != NULL) {
-                if(lv_obj_get_hidden(child_tmp) == false && lv_obj_is_protected(child_tmp, LV_PROTECT_POS) == false) {
-                    lv_coord_t mleft = lv_obj_get_style_margin_left(child_tmp, LV_OBJ_PART_MAIN);
-                    lv_coord_t mright = lv_obj_get_style_margin_right(child_tmp, LV_OBJ_PART_MAIN);
-                    switch(type) {
-                        case LV_LAYOUT_PRETTY_TOP:
-                            lv_obj_align(child_tmp, cont, align,
-                                         inv * (act_x + mleft),
-                                         act_y + lv_obj_get_style_margin_top(child_tmp, LV_OBJ_PART_MAIN));
-                            break;
-                        case LV_LAYOUT_PRETTY_MID:
-                            lv_obj_align(child_tmp, cont, align,
-                                         inv * (act_x + mleft),
-                                         act_y + (h_row - lv_obj_get_height(child_tmp)) / 2);
-
-                            break;
-                        case LV_LAYOUT_PRETTY_BOTTOM:
-                            lv_obj_align(child_tmp, cont, align,
-                                         inv * (act_x + mleft),
-                                         act_y + h_row - lv_obj_get_height(child_tmp) - lv_obj_get_style_margin_bottom(child_tmp, LV_OBJ_PART_MAIN));
-                            break;
-                        default:
-                            break;
-                    }
-
-                    act_x += lv_obj_get_width(child_tmp) + new_pinner + mleft + mright;
-                }
-                if(child_tmp == child_rc) break;
-                child_tmp = _lv_ll_get_prev(&cont->child_ll, child_tmp);
-            }
-        }
-
-        if(child_rc == NULL) break;
-        act_y += pinner + h_row;           /*y increment*/
-        child_rs = _lv_ll_get_prev(&cont->child_ll, child_rc); /*Go to the next object*/
-        child_rc = child_rs;
-    }
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the grid layout. Align same-sized objects in a grid
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_grid(lv_obj_t * cont)
-{
-    lv_coord_t w_fit         =  lv_obj_get_width_fit(cont);
-    lv_coord_t inner = lv_obj_get_style_pad_inner(cont, LV_CONT_PART_MAIN);
-    lv_coord_t y_ofs = inner + lv_obj_get_height(lv_obj_get_child(cont, NULL));
-
-    /* Disable child change action because the children will be moved a lot
-     * an unnecessary child change signals could be sent*/
-    lv_obj_add_protect(cont, LV_PROTECT_CHILD_CHG);
-
-    /* Align the children */
-    lv_coord_t left = lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-    lv_coord_t act_x = left;
-    lv_coord_t act_y = lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-    lv_obj_t * child;
-    _LV_LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-        lv_coord_t obj_w = lv_obj_get_width(child);
-        if(act_x + obj_w > w_fit + left) {
-            act_x = left;
-            act_y += y_ofs;
-        }
-
-        lv_obj_set_pos(child, act_x, act_y);
-        act_x += inner + obj_w;
-    }
-
-    lv_obj_clear_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle auto fit. Set the size of the object to involve all children.
- * @param cont pointer to an object which size will be modified
- */
-static void lv_cont_refr_autofit(lv_obj_t * cont)
-{
-    if(lv_obj_is_protected(cont, LV_PROTECT_CHILD_CHG)) return;
-    lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
-
-    if(ext->fit_left == LV_FIT_NONE && ext->fit_right == LV_FIT_NONE && ext->fit_top == LV_FIT_NONE &&
-       ext->fit_bottom == LV_FIT_NONE) {
-        return;
-    }
-
-    lv_area_t tight_area;
-    lv_area_t ori;
-    lv_obj_t * child_i;
-
-    lv_obj_t * par               = lv_obj_get_parent(cont);
-    lv_area_t parent_area;
-    lv_area_copy(&parent_area, &par->coords);
-    parent_area.x1 += lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
-    parent_area.x2 -= lv_obj_get_style_pad_right(par, LV_OBJ_PART_MAIN);
-    parent_area.y1 += lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
-    parent_area.y2 -= lv_obj_get_style_pad_bottom(par, LV_OBJ_PART_MAIN);
-
-    /*Search the side coordinates of the children*/
-    lv_obj_get_coords(cont, &ori);
-    lv_obj_get_coords(cont, &tight_area);
-
-    bool has_children = _lv_ll_is_empty(&cont->child_ll) ? false : true;
-
-    if(has_children) {
-        tight_area.x1 = LV_COORD_MAX;
-        tight_area.y1 = LV_COORD_MAX;
-        tight_area.x2 = LV_COORD_MIN;
-        tight_area.y2 = LV_COORD_MIN;
-
-        _LV_LL_READ(cont->child_ll, child_i) {
-            if(lv_obj_get_hidden(child_i) != false) continue;
-
-            if(ext->fit_left != LV_FIT_PARENT) {
-                lv_style_int_t mleft = lv_obj_get_style_margin_left(child_i, LV_OBJ_PART_MAIN);
-                tight_area.x1 = LV_MATH_MIN(tight_area.x1, child_i->coords.x1 - mleft);
-            }
-
-            if(ext->fit_right != LV_FIT_PARENT) {
-                lv_style_int_t mright = lv_obj_get_style_margin_right(child_i, LV_OBJ_PART_MAIN);
-                tight_area.x2 = LV_MATH_MAX(tight_area.x2, child_i->coords.x2 + mright);
-            }
-
-            if(ext->fit_top != LV_FIT_PARENT) {
-                lv_style_int_t mtop = lv_obj_get_style_margin_top(child_i, LV_OBJ_PART_MAIN);
-                tight_area.y1 = LV_MATH_MIN(tight_area.y1, child_i->coords.y1 - mtop);
-            }
-
-            if(ext->fit_bottom != LV_FIT_PARENT) {
-                lv_style_int_t mbottom = lv_obj_get_style_margin_bottom(child_i, LV_OBJ_PART_MAIN);
-                tight_area.y2 = LV_MATH_MAX(tight_area.y2, child_i->coords.y2 + mbottom);
-            }
-        }
-
-        tight_area.x1 -= lv_obj_get_style_pad_left(cont, LV_CONT_PART_MAIN);
-        tight_area.x2 += lv_obj_get_style_pad_right(cont, LV_CONT_PART_MAIN);
-        tight_area.y1 -= lv_obj_get_style_pad_top(cont, LV_CONT_PART_MAIN);
-        tight_area.y2 += lv_obj_get_style_pad_bottom(cont, LV_CONT_PART_MAIN);
-    }
-
-    lv_area_t new_area;
-    lv_area_copy(&new_area, &ori);
-
-    switch(ext->fit_left) {
-        case LV_FIT_TIGHT:
-            new_area.x1 = tight_area.x1;
-            break;
-        case LV_FIT_PARENT:
-            new_area.x1 = parent_area.x1;
-            break;
-        case LV_FIT_MAX:
-            new_area.x1 = has_children ? LV_MATH_MIN(tight_area.x1, parent_area.x1) : parent_area.x1;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_right) {
-        case LV_FIT_TIGHT:
-            new_area.x2 = tight_area.x2;
-            break;
-        case LV_FIT_PARENT:
-            new_area.x2 = parent_area.x2;
-            break;
-        case LV_FIT_MAX:
-            new_area.x2 = has_children ? LV_MATH_MAX(tight_area.x2, parent_area.x2) : parent_area.x2;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_top) {
-        case LV_FIT_TIGHT:
-            new_area.y1 = tight_area.y1;
-            break;
-        case LV_FIT_PARENT:
-            new_area.y1 = parent_area.y1;
-            break;
-        case LV_FIT_MAX:
-            new_area.y1 = has_children ? LV_MATH_MIN(tight_area.y1, parent_area.y1) : parent_area.y1;
-            break;
-        default:
-            break;
-    }
-
-    switch(ext->fit_bottom) {
-        case LV_FIT_TIGHT:
-            new_area.y2 = tight_area.y2;
-            break;
-        case LV_FIT_PARENT:
-            new_area.y2 = parent_area.y2;
-            break;
-        case LV_FIT_MAX:
-            new_area.y2 = has_children ? LV_MATH_MAX(tight_area.y2, parent_area.y2) : parent_area.y2;
-            break;
-        default:
-            break;
-    }
-
-    /*Do nothing if the coordinates are not changed*/
-    if(cont->coords.x1 != new_area.x1 || cont->coords.y1 != new_area.y1 || cont->coords.x2 != new_area.x2 ||
-       cont->coords.y2 != new_area.y2) {
-
-        lv_obj_invalidate(cont);
-        lv_area_copy(&cont->coords, &new_area);
-        lv_obj_invalidate(cont);
-
-        /*Notify the object about its new coordinates*/
-        cont->signal_cb(cont, LV_SIGNAL_COORD_CHG, &ori);
-
-        /*Inform the parent about the new coordinates*/
-        par->signal_cb(par, LV_SIGNAL_CHILD_CHG, cont);
-
-        if(lv_obj_get_auto_realign(cont)) {
-            lv_obj_realign(cont);
-        }
-
-        /*Tell the children the parent's size has changed*/
-        _LV_LL_READ(cont->child_ll, child_i) {
-            child_i->signal_cb(child_i, LV_SIGNAL_PARENT_SIZE_CHG, &ori);
-        }
-    }
-}
-
-#endif

From f162a4ca2f664a60f56f8d6499f6cfe20730dcc1 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 28 Oct 2020 14:39:58 +0100
Subject: [PATCH 63/84] lv_mem_alloc: speedup with incremental allocation

---
 src/lv_misc/lv_mem.c | 82 +++++++++++++++++++++-----------------------
 1 file changed, 39 insertions(+), 43 deletions(-)

diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 3ef1bd9ae..05307f3cc 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -29,7 +29,7 @@
 #endif
 
 #ifndef LV_MEM_FULL_DEFRAG_CNT
-    #define LV_MEM_FULL_DEFRAG_CNT 16
+    #define LV_MEM_FULL_DEFRAG_CNT 32
 #endif
 
 #ifdef LV_ARCH_64
@@ -72,6 +72,7 @@ typedef struct {
  *  STATIC PROTOTYPES
  **********************/
 #if LV_MEM_CUSTOM == 0
+    static void * alloc_core(size_t size);
     static lv_mem_ent_t * ent_get_next(lv_mem_ent_t * act_e);
     static inline void * ent_alloc(lv_mem_ent_t * e, size_t size);
     static void ent_trunc(lv_mem_ent_t * e, size_t size);
@@ -82,6 +83,7 @@ typedef struct {
  **********************/
 #if LV_MEM_CUSTOM == 0
     static uint8_t * work_mem;
+    static lv_mem_ent_t  * last_ent;
 #endif
 
 static uint32_t zero_mem;   /*Give the address of this variable if 0 byte should be allocated*/
@@ -169,18 +171,14 @@ void * lv_mem_alloc(size_t size)
     void * alloc = NULL;
 
 #if LV_MEM_CUSTOM == 0
-    /*Use the built-in allocators*/
-    lv_mem_ent_t * e = NULL;
 
-    /* Search for a appropriate entry*/
-    do {
-        /* Get the next entry*/
-        e = ent_get_next(e);
-        if( e == NULL) break;
-        /*If there is next entry then try to allocate there*/
-        if(!e->header.s.used && e->header.s.d_size >= size) alloc = ent_alloc(e, size);
-        /* End if the alloc. is successful*/
-    } while(alloc == NULL);
+    alloc = alloc_core(size);
+
+    if(alloc == NULL) {
+        LV_LOG_WARN("Perform defrag");
+        lv_mem_defrag();
+        alloc = alloc_core(size);
+    }
 
 #else
     /*Use custom, user defined malloc function*/
@@ -232,41 +230,13 @@ void lv_mem_free(const void * data)
     _lv_memset((void *)data, 0xbb, _lv_mem_get_size(data));
 #endif
 
+/*Use custom, user defined free function*/
+#if LV_MEM_CUSTOM
+
 #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.s.used = 0;
-#endif
-
-#if LV_MEM_CUSTOM == 0
-#if LV_MEM_AUTO_DEFRAG
-    static uint16_t full_defrag_cnt = 0;
-    full_defrag_cnt++;
-    if(full_defrag_cnt < LV_MEM_FULL_DEFRAG_CNT) {
-        /* 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.s.used == 0) {
-                e->header.s.d_size += e_next->header.s.d_size + sizeof(e->header);
-            }
-            else {
-                break;
-            }
-            e_next = ent_get_next(e_next);
-        }
-    }
-    else {
-        full_defrag_cnt = 0;
-        lv_mem_defrag();
-
-    }
-
-
-#endif /*LV_MEM_AUTO_DEFRAG*/
-#else /*Use custom, user defined free function*/
-#if LV_ENABLE_GC == 0
     LV_MEM_CUSTOM_FREE(e);
 #else
     LV_MEM_CUSTOM_FREE((void *)data);
@@ -354,6 +324,7 @@ void lv_mem_defrag(void)
     lv_mem_ent_t * e_free;
     lv_mem_ent_t * e_next;
     e_free = ent_get_next(NULL);
+    last_ent = NULL;
 
     while(1) {
         /*Search the next free entry*/
@@ -367,6 +338,7 @@ void lv_mem_defrag(void)
         }
 
         if(e_free == NULL) return;
+        if(last_ent == NULL) last_ent = e_free;
 
         /*Joint the following free entries to the free*/
         e_next = ent_get_next(e_free);
@@ -808,6 +780,30 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_ff(void * dst, size_t len)
  **********************/
 
 #if LV_MEM_CUSTOM == 0
+
+static void * alloc_core(size_t size)
+{
+    void * alloc = NULL;
+
+//    lv_mem_ent_t * e = NULL;
+    lv_mem_ent_t * e = last_ent;
+
+    /* Search for a appropriate entry*/
+    if(e == NULL) e = ent_get_next(NULL);
+    do {
+        /* Get the next entry*/
+        /*If there is next entry then try to allocate there*/
+        if(!e->header.s.used && e->header.s.d_size >= size) alloc = ent_alloc(e, size);
+
+        e = ent_get_next(e);
+        if( e == NULL) break;
+
+        /* End if the alloc. is successful*/
+    } while(alloc == NULL);
+    last_ent = e;
+
+    return alloc;
+}
 /**
  * Give the next entry after 'act_e'
  * @param act_e pointer to an entry

From 6bc4f00bf0e9c627eaf98232b0bc376dc2e5722f Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 28 Oct 2020 14:40:14 +0100
Subject: [PATCH 64/84] minor fixes

---
 lvgl.mk                       | 11 +-------
 src/lv_core/lv_flex.c         | 12 ++++++---
 src/lv_core/lv_obj.c          | 49 ++++++++++++++++++++++-------------
 src/lv_core/lv_obj.h          | 13 ++++++++--
 src/lv_core/lv_obj_style.c    |  2 +-
 src/lv_widgets/lv_btnmatrix.c |  5 ++--
 src/lv_widgets/lv_btnmatrix.h |  8 ++++++
 7 files changed, 62 insertions(+), 38 deletions(-)

diff --git a/lvgl.mk b/lvgl.mk
index bbea98d35..f2eabe8be 100644
--- a/lvgl.mk
+++ b/lvgl.mk
@@ -1,10 +1 @@
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core/lv_core.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_hal/lv_hal.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_widgets/lv_widgets.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_font/lv_font.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_misc/lv_misc.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_themes/lv_themes.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_draw/lv_draw.mk
-include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_gpu/lv_gpu.mk
-
-
+CSRCS += $(shell find -L lvgl -name \*.c)
diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index ab80f13d6..c75e66bc0 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -66,14 +66,14 @@ void _lv_flex_refresh(lv_obj_t * cont)
 {
     if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return;
 
-    lv_flex_dir_t dir = cont->flex_cont.dir;
+    lv_flex_dir_t dir = cont->flex_cont.dir & 0x3;
     bool row = dir == LV_FLEX_DIR_ROW ? true : false;
     /*Count the grow units and free space*/
     lv_coord_t max_main_size = (row ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
 
-    lv_coord_t * cross_pos = (dir == LV_FLEX_DIR_ROW ? &abs_y : &abs_x);
+    lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
 
     lv_coord_t place = cont->flex_cont.place;
     if((row && cont->h_set == LV_SIZE_AUTO) ||
@@ -125,7 +125,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
 static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
 {
     lv_flex_dir_t dir = cont->flex_cont.dir;
-    bool row = dir == LV_FLEX_DIR_ROW ? true : false;
+    bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
     lv_coord_t(*get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
@@ -184,7 +184,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
 static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
 {
     lv_flex_dir_t dir = cont->flex_cont.dir;
-    bool row = dir == LV_FLEX_DIR_ROW ? true : false;
+    bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
     lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (row ? lv_area_set_width : lv_area_set_height);
@@ -234,9 +234,13 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         lv_coord_t diff_x;
         lv_coord_t diff_y;
         if(row) {
+            cross_pos += lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
+            main_pos += lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
             diff_x = abs_x + main_pos - item->coords.x1;
             diff_y = abs_y + cross_pos - item->coords.y1;
         } else {
+            main_pos += lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
+            cross_pos += lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
             diff_x = abs_x + cross_pos - item->coords.x1;
             diff_y = abs_y + main_pos - item->coords.y1;
         }
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index eca9d57cd..2fffbe30a 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -896,11 +896,9 @@ void lv_event_send_refresh_recursive(lv_obj_t * obj)
         lv_res_t res = lv_event_send_refresh(obj);
         if(res != LV_RES_OK) return; /*If invalid returned do not check the children*/
 
-        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-        while(child) {
+        lv_obj_t * child;
+        _LV_LL_READ(obj->child_ll, child) {
             lv_event_send_refresh_recursive(child);
-
-            child = lv_obj_get_child(obj, child);
         }
     }
 }
@@ -1173,11 +1171,11 @@ uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
     if(parent == NULL) return 0;
 
     uint32_t id = 0;
-    lv_obj_t * child = lv_obj_get_child_back(parent, NULL);
-    while(child) {
+    lv_obj_t * child;
+
+    _LV_LL_READ_BACK(obj->child_ll, child) {
         if(child == obj) return id;
         id++;
-        child = lv_obj_get_child_back(parent, child);
     }
     return id;
 }
@@ -1187,7 +1185,7 @@ uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
  * @param obj pointer to an object
  * @return children number of 'obj'
  */
-uint16_t lv_obj_count_children(const lv_obj_t * obj)
+uint32_t lv_obj_count_children(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -1203,7 +1201,7 @@ uint16_t lv_obj_count_children(const lv_obj_t * obj)
  * @param obj pointer to an object
  * @return children number of 'obj'
  */
-uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj)
+uint32_t lv_obj_count_children_recursive(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -1509,6 +1507,24 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
 #endif
 }
 
+/**
+ * Tell if an object is an instance of a certain widget type or not
+ * @param obj pointer to an object
+ * @param type_str the type to check. The name of the widget's type, g.g. "lv_label", "lv_btn", etc
+ * @return true: `obj` has the given type
+ * @note Not only the "final" type matters. Therefore every widget has "lv_obj" type and "lv_slider" is an "lv_bar" too.
+ */
+bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str)
+{
+    lv_obj_type_t type;
+    lv_obj_get_type(obj, &type);
+    uint8_t cnt;
+    for(cnt = 0; cnt < LV_MAX_ANCESTOR_NUM; cnt++) {
+        if(type.type[cnt] == NULL) break;
+        if(!strcmp(type.type[cnt], type_str)) return true;
+    }
+    return false;
+}
 
 /*-------------------
  * OTHER FUNCTIONS
@@ -1610,7 +1626,8 @@ static void lv_obj_del_async_cb(void * obj)
 static void obj_del_core(lv_obj_t * obj)
 {
     /*Let the user free the resources used in `LV_EVENT_DELETE`*/
-    lv_event_send(obj, LV_EVENT_DELETE, NULL);
+    lv_res_t res = lv_event_send(obj, LV_EVENT_DELETE, NULL);
+    if(res == LV_RES_INV) return;
 
     /*Delete from the group*/
 #if LV_USE_GROUP
@@ -1825,15 +1842,11 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
 static void base_dir_refr_children(lv_obj_t * obj)
 {
     lv_obj_t * child;
-    child = lv_obj_get_child(obj, NULL);
-
-    while(child) {
+    _LV_LL_READ(obj->child_ll, child) {
         if(child->base_dir == LV_BIDI_DIR_INHERIT) {
             lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
             base_dir_refr_children(child);
         }
-
-        child = lv_obj_get_child(obj, child);
     }
 }
 
@@ -1991,12 +2004,12 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if(obj->grid) _lv_grid_full_refresh(obj);
 
         /*Reposition non grid objects on by one*/
-        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-        while(child) {
+        lv_obj_t * child;
+
+        _LV_LL_READ(obj->child_ll, child) {
             if(!LV_COORD_IS_GRID(child->x_set) || !LV_COORD_IS_GRID(child->y_set)) {
                 lv_obj_set_pos(child, child->x_set, child->y_set);
             }
-            child = lv_obj_get_child(obj, child);
         }
 
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index a986aa94d..5fdcc4f0a 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -616,13 +616,13 @@ uint32_t lv_obj_get_child_id(const lv_obj_t * obj);
  * @param obj pointer to an object
  * @return children number of 'obj'
  */
-uint16_t lv_obj_count_children(const lv_obj_t * obj);
+uint32_t lv_obj_count_children(const lv_obj_t * obj);
 
 /** Recursively count the children of an object
  * @param obj pointer to an object
  * @return children number of 'obj'
  */
-uint16_t lv_obj_count_children_recursive(const lv_obj_t * obj);
+uint32_t lv_obj_count_children_recursive(const lv_obj_t * obj);
 
 /*---------------------
  * Coordinate get
@@ -751,6 +751,15 @@ void * lv_obj_get_group(const lv_obj_t * obj);
  */
 bool lv_obj_is_focused(const lv_obj_t * obj);
 
+/**
+ * Tell if an object is an instance of a certain widget type or not
+ * @param obj pointer to an object
+ * @param type_str the type to check. The name of the widget's type, g.g. "lv_label", "lv_btn", etc
+ * @return true: `obj` has the given type
+ * @note Not only the "final" type matters. Therefore every widget has "lv_obj" type and "lv_slider" is an "lv_bar" too.
+ */
+bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str);
+
 /**
  * Get the really focused object by taking `focus_parent` into account.
  * @param obj the start object
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index 16b4d49cb..fbd02c2f1 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -1454,7 +1454,7 @@ static void update_style_cache(lv_obj_t * obj, uint8_t part, uint16_t prop)
 #endif
     if(pad_top != 0 ||
        pad_left != 0 ||
-       lv_obj_get_style_pad_left(obj, part) != 0 ||
+       lv_obj_get_style_pad_bottom(obj, part) != 0 ||
        lv_obj_get_style_pad_right(obj, part) != 0) {
         list->pad_all_zero  = 0;
     }
diff --git a/src/lv_widgets/lv_btnmatrix.c b/src/lv_widgets/lv_btnmatrix.c
index 10fe00b1f..05de2dd79 100644
--- a/src/lv_widgets/lv_btnmatrix.c
+++ b/src/lv_widgets/lv_btnmatrix.c
@@ -196,8 +196,7 @@ void lv_btnmatrix_set_map(lv_obj_t * btnm, const char * map[])
         }
 
         lv_coord_t row_y1 = top + (max_h_no_gap * row) / row_cnt + row * row_gap;
-        lv_coord_t row_y2 = top + (max_h_no_gap * (row + 1)) / row_cnt + row * row_gap;
-
+        lv_coord_t row_y2 = top + (max_h_no_gap * (row + 1)) / row_cnt + row * row_gap - 1;
 
         /*Set the button size and positions*/
         lv_coord_t max_w_no_gap = max_w - (col_gap * (btn_cnt - 1));
@@ -209,7 +208,7 @@ void lv_btnmatrix_set_map(lv_obj_t * btnm, const char * map[])
             uint32_t btn_u = get_button_width(ext->ctrl_bits[btn_tot_i]);
 
             lv_coord_t btn_x1 = left + (max_w_no_gap * row_unit_cnt) / unit_cnt + btn * col_gap;
-            lv_coord_t btn_x2 = left + (max_w_no_gap * (row_unit_cnt + btn_u)) / unit_cnt + btn * col_gap;
+            lv_coord_t btn_x2 = left + (max_w_no_gap * (row_unit_cnt + btn_u)) / unit_cnt + btn * col_gap - 1;
 
             /*If RTL start from the right*/
             if(base_dir == LV_BIDI_DIR_RTL) {
diff --git a/src/lv_widgets/lv_btnmatrix.h b/src/lv_widgets/lv_btnmatrix.h
index be636b390..545f550cf 100644
--- a/src/lv_widgets/lv_btnmatrix.h
+++ b/src/lv_widgets/lv_btnmatrix.h
@@ -207,6 +207,14 @@ bool lv_btnmatrix_get_recolor(const lv_obj_t * btnm);
  */
 uint16_t lv_btnmatrix_get_active_btn(const lv_obj_t * btnm);
 
+/**
+ * Get the text of the lastly "activated" button by the user (pressed, released etc)
+ * Useful in the the `event_cb`
+ * @param btnm pointer to button matrix object
+ * @return text of the last released button (NULL: if unset)
+ */
+const char * lv_btnmatrix_get_active_btn_text(const lv_obj_t * btnm);
+
 /**
  * Get the focused button's index.
  * @param btnm pointer to button matrix object

From 54fa0dc28be433cb0a8c241b76b9e15290ec3846 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 28 Oct 2020 14:50:42 +0100
Subject: [PATCH 65/84] fix lv_mem_free

---
 src/lv_misc/lv_mem.c | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 05307f3cc..6c5817bc5 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -172,11 +172,27 @@ void * lv_mem_alloc(size_t size)
 
 #if LV_MEM_CUSTOM == 0
 
+    lv_mem_monitor_t mon;
+    lv_mem_monitor(&mon);
     alloc = alloc_core(size);
+    printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
+           (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
+           (int)mon.free_biggest_size);
+    lv_mem_defrag();
 
     if(alloc == NULL) {
         LV_LOG_WARN("Perform defrag");
+
+        lv_mem_monitor(&mon);
+        printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
+               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
+               (int)mon.free_biggest_size);
         lv_mem_defrag();
+
+        lv_mem_monitor(&mon);
+        printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
+               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
+               (int)mon.free_biggest_size);
         alloc = alloc_core(size);
     }
 
@@ -230,13 +246,18 @@ void lv_mem_free(const void * data)
     _lv_memset((void *)data, 0xbb, _lv_mem_get_size(data));
 #endif
 
-/*Use custom, user defined free function*/
-#if LV_MEM_CUSTOM
 
 #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));
+#endif
+
+/*Use custom, user defined free function*/
+#if LV_MEM_CUSTOM == 0
     e->header.s.used = 0;
+#else
+#if LV_ENABLE_GC == 0
+    /*e points to the header*/
     LV_MEM_CUSTOM_FREE(e);
 #else
     LV_MEM_CUSTOM_FREE((void *)data);

From e6738a26178022c19685745cc423d49bedf3256a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Wed, 28 Oct 2020 14:58:44 +0100
Subject: [PATCH 66/84] remove debug code

---
 src/lv_misc/lv_mem.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 6c5817bc5..c41ea98eb 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -171,17 +171,16 @@ void * lv_mem_alloc(size_t size)
     void * alloc = NULL;
 
 #if LV_MEM_CUSTOM == 0
-
-    lv_mem_monitor_t mon;
-    lv_mem_monitor(&mon);
+    static uint32_t defr = 0;
+    defr++;
+    if(defr > LV_MEM_FULL_DEFRAG_CNT) {
+        defr = 0;
+        lv_mem_defrag();
+    }
     alloc = alloc_core(size);
-    printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
-           (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
-           (int)mon.free_biggest_size);
-    lv_mem_defrag();
-
     if(alloc == NULL) {
         LV_LOG_WARN("Perform defrag");
+        lv_mem_monitor_t mon;
 
         lv_mem_monitor(&mon);
         printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",

From 7a950f18639481bdcf96bdc4676d0798c31334f0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 29 Oct 2020 14:51:36 +0100
Subject: [PATCH 67/84] introduce lv_obj_rare_attr_t

---
 src/lv_core/lv_flex.c             |  18 +++--
 src/lv_core/lv_grid.c             |   2 +-
 src/lv_core/lv_group.c            |  10 +--
 src/lv_core/lv_indev.c            |   3 +-
 src/lv_core/lv_obj.c              | 105 +++++++++++++++++++++---------
 src/lv_core/lv_obj.h              |  14 +++-
 src/lv_core/lv_obj_draw.c         |  16 +++--
 src/lv_core/lv_obj_pos.c          |   3 +-
 src/lv_core/lv_obj_scroll.c       |  33 ++++++----
 src/lv_core/lv_obj_style.c        |   4 +-
 src/lv_core/lv_refr.c             |  11 ++--
 src/lv_draw/lv_img_decoder.c      |   4 +-
 src/lv_hal/lv_hal_disp.c          |   2 +-
 src/lv_misc/lv_anim.c             |   6 +-
 src/lv_misc/lv_fs.c               |   4 +-
 src/lv_misc/lv_ll.c               |  22 +++++++
 src/lv_misc/lv_ll.h               |  14 ++--
 src/lv_misc/lv_mem.c              |   2 +-
 src/lv_misc/lv_task.c             |   2 +-
 src/lv_themes/lv_theme_material.c |   1 +
 20 files changed, 185 insertions(+), 91 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index c75e66bc0..d28e3f143 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -73,6 +73,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
 
+    lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
 
     lv_coord_t place = cont->flex_cont.place;
@@ -92,7 +93,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
     bool rev = cont->flex_cont.dir & LV_FLEX_REVERSE;
 
     if(place != LV_FLEX_START) {
-        track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
+        track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
 
         while(track_first_item) {
             /*Search the first item of the next row */
@@ -106,7 +107,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
         place_content(place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
     }
 
-    track_first_item =  rev ? _lv_ll_get_head(&cont->child_ll) : _lv_ll_get_tail(&cont->child_ll);
+    track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
     while(track_first_item) {
         /*Search the first item of the next row */
         next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
@@ -131,6 +132,8 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
     void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
     bool wrap = dir & LV_FLEX_WRAP ? true : false;
 
+    lv_ll_t * ll = _lv_obj_get_child_ll(cont);
+
     lv_coord_t grow_sum = 0;
     lv_coord_t used_size = 0;
     lv_coord_t gap = cont->flex_cont.gap;
@@ -143,7 +146,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
         /*Ignore non-flex items*/
         lv_coord_t main_set = (row ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
-            item = ll_iter(&cont->child_ll, item);
+            item = ll_iter(ll, item);
             continue;
         }
 
@@ -158,7 +161,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
         }
         *track_cross_size = LV_MATH_MAX(get_cross_size(item), *track_cross_size);
 
-        item = ll_iter(&cont->child_ll, item);
+        item = ll_iter(ll, item);
     }
 
     if(used_size > 0) used_size -= gap; /*There is no gap after the last item*/
@@ -173,7 +176,7 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
 
     /*Have at least one item in a row*/
     if(item && item == item_start) {
-        item = ll_iter(&cont->child_ll, item);
+        item = ll_iter(ll, item);
         if(item) *track_cross_size = get_cross_size(item);
     }
 
@@ -193,6 +196,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
     lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
     void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
 
+    lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t gap = cont->flex_cont.gap;
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
@@ -202,7 +206,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         /*Ignore non-flex items*/
         lv_coord_t main_set = (row ? item->x_set : item->y_set);
         if(LV_COORD_IS_FLEX(main_set) == false) {
-            item = ll_iter(&cont->child_ll, item);
+            item = ll_iter(ll, item);
             continue;
         }
 
@@ -253,7 +257,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             _lv_obj_move_children_by(item, diff_x, diff_y);
         }
         main_pos += obj_get_main_size(item) + gap;
-        item = ll_iter(&cont->child_ll, item);
+        item = ll_iter(ll, item);
     }
 }
 
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index c4ed0a59b..dfbe1434e 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -81,7 +81,7 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
 
     while(d) {
         lv_obj_t * i;
-        _LV_LL_READ(d->scr_ll, i) {
+        _LV_LL_READ(&d->scr_ll, i) {
             report_grid_change_core(grid, i);
         }
         d = lv_disp_get_next(d);
diff --git a/src/lv_core/lv_group.c b/src/lv_core/lv_group.c
index 78fe73ea7..32f906dc5 100644
--- a/src/lv_core/lv_group.c
+++ b/src/lv_core/lv_group.c
@@ -92,7 +92,7 @@ void lv_group_del(lv_group_t * group)
 
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
-    _LV_LL_READ(group->obj_ll, obj) {
+    _LV_LL_READ(&group->obj_ll, obj) {
         (*obj)->group_p = NULL;
     }
 
@@ -111,7 +111,7 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
     if(group == NULL) return;
     /*Do not add the object twice*/
     lv_obj_t ** obj_i;
-    _LV_LL_READ(group->obj_ll, obj_i) {
+    _LV_LL_READ(&group->obj_ll, obj_i) {
         if((*obj_i) == obj) {
             LV_LOG_INFO("lv_group_add_obj: the object is already added to this group");
             return;
@@ -173,7 +173,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
 
     /*Search the object and remove it from its group */
     lv_obj_t ** i;
-    _LV_LL_READ(g->obj_ll, i) {
+    _LV_LL_READ(&g->obj_ll, i) {
         if(*i == obj) {
             _lv_ll_remove(&g->obj_ll, i);
             lv_mem_free(i);
@@ -198,7 +198,7 @@ void lv_group_remove_all_objs(lv_group_t * group)
 
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
-    _LV_LL_READ(group->obj_ll, obj) {
+    _LV_LL_READ(&group->obj_ll, obj) {
         (*obj)->group_p = NULL;
     }
 
@@ -223,7 +223,7 @@ void lv_group_focus_obj(lv_obj_t * obj)
     lv_group_set_editing(g, false);
 
     lv_obj_t ** i;
-    _LV_LL_READ(g->obj_ll, i) {
+    _LV_LL_READ(&g->obj_ll, i) {
         if(*i == obj) {
             if(g->obj_focus != NULL) {
                 (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
diff --git a/src/lv_core/lv_indev.c b/src/lv_core/lv_indev.c
index e3d53935f..6be36ad7d 100644
--- a/src/lv_core/lv_indev.c
+++ b/src/lv_core/lv_indev.c
@@ -1048,7 +1048,8 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
     if(lv_obj_hit_test(obj, point)) {
         lv_obj_t * i;
 
-        _LV_LL_READ(obj->child_ll, i) {
+        lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+        _LV_LL_READ(ll, i) {
             found_p = lv_indev_search_obj(i, point);
 
             /*If a child was found then break*/
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 2fffbe30a..427618dfa 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -225,8 +225,10 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     else {
         LV_LOG_TRACE("Object create started");
         LV_ASSERT_OBJ(parent, LV_OBJX_NAME);
-
-        new_obj = _lv_ll_ins_head(&parent->child_ll);
+        if(parent->rare_attr == NULL) {
+            parent->rare_attr = lv_obj_allocate_rare_attr(parent);
+        }
+        new_obj = _lv_ll_ins_head(&parent->rare_attr->child_ll);
         LV_ASSERT_MEM(new_obj);
         if(new_obj == NULL) return NULL;
 
@@ -260,9 +262,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     }
 
 
-    _lv_ll_init(&(new_obj->child_ll), sizeof(lv_obj_t));
-
-
     new_obj->ext_draw_pad = 0;
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
@@ -293,8 +292,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->flags |= LV_OBJ_FLAG_SCROLL_MOMENTUM;
     if(parent) new_obj->flags |= LV_OBJ_FLAG_GESTURE_BUBBLE;
     new_obj->state = LV_STATE_DEFAULT;
-    new_obj->scroll.x = 0;
-    new_obj->scroll.y = 0;
 
     new_obj->ext_attr = NULL;
 
@@ -562,6 +559,10 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
 
     lv_obj_invalidate(obj);
 
+    if(parent->rare_attr == NULL) {
+        parent->rare_attr = lv_obj_allocate_rare_attr(parent);
+    }
+
     lv_obj_t * old_par = obj->parent;
     lv_point_t old_pos;
     old_pos.y = lv_obj_get_y(obj);
@@ -575,7 +576,7 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
         old_pos.x = old_par->coords.x2 - obj->coords.x2;
     }
 
-    _lv_ll_chg_list(&obj->parent->child_ll, &parent->child_ll, obj, true);
+    _lv_ll_chg_list(_lv_obj_get_child_ll(obj->parent), _lv_obj_get_child_ll(parent), obj, true);
     obj->parent = parent;
 
 
@@ -606,13 +607,14 @@ void lv_obj_move_foreground(lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
+    lv_ll_t * ll = _lv_obj_get_child_ll(parent);
 
     /*Do nothing of already in the foreground*/
-    if(_lv_ll_get_head(&parent->child_ll) == obj) return;
+    if(_lv_ll_get_head(ll) == obj) return;
 
     lv_obj_invalidate(parent);
 
-    _lv_ll_chg_list(&parent->child_ll, &parent->child_ll, obj, true);
+    _lv_ll_chg_list(ll, ll, obj, true);
 
     /*Notify the new parent about the child*/
     parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
@@ -629,13 +631,14 @@ void lv_obj_move_background(lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
+    lv_ll_t * ll = _lv_obj_get_child_ll(parent);
 
     /*Do nothing of already in the background*/
-    if(_lv_ll_get_tail(&parent->child_ll) == obj) return;
+    if(_lv_ll_get_tail(ll) == obj) return;
 
     lv_obj_invalidate(parent);
 
-    _lv_ll_chg_list(&parent->child_ll, &parent->child_ll, obj, false);
+    _lv_ll_chg_list(ll, ll, obj, false);
 
     /*Notify the new parent about the child*/
     parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
@@ -897,7 +900,8 @@ void lv_event_send_refresh_recursive(lv_obj_t * obj)
         if(res != LV_RES_OK) return; /*If invalid returned do not check the children*/
 
         lv_obj_t * child;
-        _LV_LL_READ(obj->child_ll, child) {
+        lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+        _LV_LL_READ(ll, child) {
             lv_event_send_refresh_recursive(child);
         }
     }
@@ -1034,12 +1038,38 @@ void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     void * new_ext = lv_mem_realloc(obj->ext_attr, ext_size);
+    LV_ASSERT_MEM(new_ext);
     if(new_ext == NULL) return NULL;
 
     obj->ext_attr = new_ext;
     return (void *)obj->ext_attr;
 }
 
+/**
+ * Allocate a new ext. data for an object
+ * @param obj pointer to an object
+ * @param ext_size the size of the new ext. data
+ * @return pointer to the allocated ext.
+ * If out of memory NULL is returned and the original ext is preserved
+ */
+lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+
+    if(obj->rare_attr == NULL) {
+        obj->rare_attr = lv_mem_realloc(obj->ext_attr, sizeof(lv_obj_rare_attr_t));
+        LV_ASSERT_MEM(obj->rare_attr);
+        if(obj->rare_attr == NULL) return NULL;
+
+        _lv_memset_00(obj->rare_attr, sizeof(lv_obj_rare_attr_t));
+        _lv_ll_init(&(obj->rare_attr->child_ll), sizeof(lv_obj_t));
+
+    }
+    return obj->rare_attr;
+}
+
+
 
 /*=======================
  * Getter functions
@@ -1082,9 +1112,9 @@ lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
         scr = lv_obj_get_screen(obj); /*get the screen of `obj`*/
 
     lv_disp_t * d;
-    _LV_LL_READ(LV_GC_ROOT(_lv_disp_ll), d) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_disp_ll), d) {
         lv_obj_t * s;
-        _LV_LL_READ(d->scr_ll, s) {
+        _LV_LL_READ(&d->scr_ll, s) {
             if(s == scr) return d;
         }
     }
@@ -1120,7 +1150,9 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, const lv_obj_t * child)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return child ? _lv_ll_get_next(&obj->child_ll, child) : _lv_ll_get_head(&obj->child_ll);
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    if (child) return _lv_ll_get_next(ll, child);
+    else return _lv_ll_get_head(ll);
 }
 
 /**
@@ -1134,7 +1166,9 @@ lv_obj_t * lv_obj_get_child_back(const lv_obj_t * obj, const lv_obj_t * child)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return child ? _lv_ll_get_prev(&obj->child_ll, child) : _lv_ll_get_tail(&obj->child_ll);
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    if(child) return _lv_ll_get_prev(ll, child);
+    else return _lv_ll_get_tail(ll);
 }
 
 /**
@@ -1173,7 +1207,8 @@ uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
     uint32_t id = 0;
     lv_obj_t * child;
 
-    _LV_LL_READ_BACK(obj->child_ll, child) {
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    _LV_LL_READ_BACK(ll, child) {
         if(child == obj) return id;
         id++;
     }
@@ -1192,7 +1227,8 @@ uint32_t lv_obj_count_children(const lv_obj_t * obj)
     lv_obj_t * i;
     uint16_t cnt = 0;
 
-    _LV_LL_READ(obj->child_ll, i) cnt++;
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    _LV_LL_READ(ll, i) cnt++;
 
     return cnt;
 }
@@ -1208,7 +1244,8 @@ uint32_t lv_obj_count_children_recursive(const lv_obj_t * obj)
     lv_obj_t * i;
     uint16_t cnt = 0;
 
-    _LV_LL_READ(obj->child_ll, i) {
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    _LV_LL_READ(ll, i) {
         cnt++;                                     /*Count the child*/
         cnt += lv_obj_count_children_recursive(i); /*recursively count children's children*/
     }
@@ -1526,6 +1563,12 @@ bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str)
     return false;
 }
 
+lv_ll_t * _lv_obj_get_child_ll(const lv_obj_t * obj)
+{
+    if(obj->rare_attr) return &obj->rare_attr->child_ll;
+    else return NULL;
+}
+
 /*-------------------
  * OTHER FUNCTIONS
  *------------------*/
@@ -1599,7 +1642,7 @@ bool _lv_debug_check_obj_valid(const lv_obj_t * obj)
     lv_disp_t * disp = lv_disp_get_next(NULL);
     while(disp) {
         lv_obj_t * scr;
-        _LV_LL_READ(disp->scr_ll, scr) {
+        _LV_LL_READ(&disp->scr_ll, scr) {
 
             if(scr == obj) return true;
             bool found = obj_valid_child(scr, obj);
@@ -1649,14 +1692,15 @@ static void obj_del_core(lv_obj_t * obj)
 #endif
 
     /*Recursively delete the children*/
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
     lv_obj_t * i;
-    i = _lv_ll_get_head(&(obj->child_ll));
+    i = _lv_ll_get_head(ll);
     while(i != NULL) {
         /*Call the recursive delete to the child too*/
         obj_del_core(i);
 
         /*Set i to the new head node*/
-        i = _lv_ll_get_head(&(obj->child_ll));
+        i = _lv_ll_get_head(ll);
     }
 
     lv_event_mark_deleted(obj);
@@ -1690,7 +1734,7 @@ static void obj_del_core(lv_obj_t * obj)
         _lv_ll_remove(&d->scr_ll, obj);
     }
     else {
-        _lv_ll_remove(&(par->child_ll), obj);
+        _lv_ll_remove(_lv_obj_get_child_ll(par), obj);
     }
 
     /*Delete the base objects*/
@@ -1842,7 +1886,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
 static void base_dir_refr_children(lv_obj_t * obj)
 {
     lv_obj_t * child;
-    _LV_LL_READ(obj->child_ll, child) {
+    _LV_LL_READ(_lv_obj_get_child_ll(obj), child) {
         if(child->base_dir == LV_BIDI_DIR_INHERIT) {
             lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
             base_dir_refr_children(child);
@@ -1953,8 +1997,9 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
 
         if(w_new || h_new) {
+            lv_ll_t * ll = _lv_obj_get_child_ll(obj);
             lv_obj_t * child;
-            _LV_LL_READ(obj->child_ll, child) {
+            _LV_LL_READ(ll, child) {
                 if((LV_COORD_IS_PCT(child->w_set) && w_new) ||
                         (LV_COORD_IS_PCT(child->h_set) && h_new))
                 {
@@ -2006,8 +2051,9 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         /*Reposition non grid objects on by one*/
         lv_obj_t * child;
 
-        _LV_LL_READ(obj->child_ll, child) {
-            if(!LV_COORD_IS_GRID(child->x_set) || !LV_COORD_IS_GRID(child->y_set)) {
+        lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+        _LV_LL_READ(ll, child) {
+            if(LV_COORD_IS_PX(child->x_set) || LV_COORD_IS_PX(child->y_set)) {
                 lv_obj_set_pos(child, child->x_set, child->y_set);
             }
         }
@@ -2039,7 +2085,8 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 {
     /*Check all children of `parent`*/
     lv_obj_t * child;
-    _LV_LL_READ(parent->child_ll, child) {
+    lv_ll_t * ll = _lv_obj_get_child_ll(parent);
+    _LV_LL_READ(ll, child) {
         if(child == obj_to_find) return true;
 
         /*Check the children*/
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 5fdcc4f0a..5fcdb9ce0 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -208,12 +208,17 @@ typedef uint16_t lv_obj_flag_t;
 #include "lv_obj_draw.h"
 
 
-struct _lv_obj_t {
-    struct _lv_obj_t * parent; /**< Pointer to the parent object*/
+typedef struct {
     lv_ll_t child_ll;       /**< Linked list to store the children objects*/
+    lv_point_t scroll; /**< The current X/Y scroll offset*/
+}lv_obj_rare_attr_t;
+
+
+struct _lv_obj_t {
+    lv_obj_rare_attr_t * rare_attr;
+    struct _lv_obj_t * parent; /**< Pointer to the parent object*/
 
     lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
-    lv_point_t scroll; /**< The current X/Y scroll offset*/
 
     lv_event_cb_t event_cb; /**< Event callback function */
     lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
@@ -548,6 +553,7 @@ void lv_obj_set_design_cb(lv_obj_t * obj, lv_design_cb_t design_cb);
  */
 void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size);
 
+lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
 /*=======================
  * Getter functions
  *======================*/
@@ -760,6 +766,8 @@ bool lv_obj_is_focused(const lv_obj_t * obj);
  */
 bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str);
 
+lv_ll_t * _lv_obj_get_child_ll(const lv_obj_t * obj) ;
+
 /**
  * Get the really focused object by taking `focus_parent` into account.
  * @param obj the start object
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index f01f26770..ac356a140 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -438,19 +438,23 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t obj_w = lv_obj_get_width(obj);
 
     bool ver_draw = false;
-    if((sm == LV_SCROLL_MODE_ON) ||
-       (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
-       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER)) {
+    if((obj->scroll_dir & LV_DIR_VER) &&
+       ((sm == LV_SCROLL_MODE_ON) ||
+        (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
+        (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER))) {
         ver_draw = true;
     }
 
+
     bool hor_draw = false;
-    if((sm == LV_SCROLL_MODE_ON) ||
-       (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
-       (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR)) {
+    if((obj->scroll_dir & LV_DIR_HOR) &&
+          ((sm == LV_SCROLL_MODE_ON) ||
+           (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
+           (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR))) {
         hor_draw = true;
     }
 
+
     lv_coord_t ver_reg_space = ver_draw ? tickness + side_space : 0;
     lv_coord_t hor_req_space = hor_draw ? tickness + side_space : 0;
     lv_coord_t rem;
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 125f65fe4..8aaabcdb1 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -694,7 +694,8 @@ void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_par
 void _lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff)
 {
     lv_obj_t * i;
-    _LV_LL_READ(obj->child_ll, i) {
+    lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+    _LV_LL_READ(ll, i) {
         i->coords.x1 += x_diff;
         i->coords.y1 += y_diff;
         i->coords.x2 += x_diff;
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index c3b9a3976..a192ed4ad 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -73,8 +73,13 @@ lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
  */
 void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 {
-    obj->scroll.x += x;
-    obj->scroll.y += y;
+    if(x == 0 && y == 0) return;
+
+    if(obj->rare_attr == NULL) {
+        obj->rare_attr = lv_obj_allocate_rare_attr(obj);
+    }
+    obj->rare_attr->scroll.x += x;
+    obj->rare_attr->scroll.y += y;
 
     _lv_obj_move_children_by(obj, x, y);
     lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
@@ -107,7 +112,8 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
             if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
             lv_anim_set_time(&a, t);
-            lv_anim_set_values(&a, obj->scroll.x, obj->scroll.x + x);
+            lv_coord_t sl = lv_obj_get_scroll_left(obj);
+            lv_anim_set_values(&a, -sl, -sl + x);
             lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
             lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
@@ -118,7 +124,8 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
             if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
             lv_anim_set_time(&a, t);
-            lv_anim_set_values(&a, obj->scroll.y, obj->scroll.y + y);
+            lv_coord_t st = lv_obj_get_scroll_top(obj);
+            lv_anim_set_values(&a, -st, -st + y);
             lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
             lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
@@ -147,7 +154,7 @@ void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  */
 void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, -x - obj->scroll.x, 0, anim_en);
+    lv_obj_scroll_by(obj, -x + lv_obj_get_scroll_left(obj), 0, anim_en);
 }
 
 /**
@@ -157,7 +164,7 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
  */
 void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, 0,  -y - obj->scroll.y, anim_en);
+    lv_obj_scroll_by(obj, 0,  -y + lv_obj_get_scroll_top(obj), anim_en);
 }
 
 
@@ -170,7 +177,8 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
  */
 lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
 {
-    return -obj->scroll.y;
+    if(obj->rare_attr == NULL) return 0;
+    return -obj->rare_attr->scroll.y;
 }
 
 /**
@@ -205,7 +213,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
 
     lv_coord_t self_h = _lv_obj_get_self_height(obj);
     self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
-    self_h += obj->scroll.y;
+    self_h -= lv_obj_get_scroll_top(obj);
     return LV_MATH_MAX(child_res, self_h);
 }
 
@@ -218,7 +226,8 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
  */
 lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 {
-    return -obj->scroll.x;
+    if(obj->rare_attr == NULL) return 0;
+    return -obj->rare_attr->scroll.x;
 }
 
 /**
@@ -251,7 +260,7 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
 
     lv_coord_t self_w = _lv_obj_get_self_width(obj);
     self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-    self_w += obj->scroll.x;
+    self_w -= lv_obj_get_scroll_left(obj);
 
     return LV_MATH_MAX(child_res, self_w);
 }
@@ -278,10 +287,10 @@ void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
 
 static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
-    _lv_obj_scroll_by_raw(obj, v - obj->scroll.x, 0);
+    _lv_obj_scroll_by_raw(obj, v + lv_obj_get_scroll_left(obj), 0);
 }
 
 static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
-    _lv_obj_scroll_by_raw(obj, 0, v - obj->scroll.y);
+    _lv_obj_scroll_by_raw(obj, 0, v + lv_obj_get_scroll_top(obj));
 }
diff --git a/src/lv_core/lv_obj_style.c b/src/lv_core/lv_obj_style.c
index fbd02c2f1..75e780843 100644
--- a/src/lv_core/lv_obj_style.c
+++ b/src/lv_core/lv_obj_style.c
@@ -191,7 +191,7 @@ void lv_obj_report_style_change(lv_style_t * style)
 
     while(d) {
         lv_obj_t * i;
-        _LV_LL_READ(d->scr_ll, i) {
+        _LV_LL_READ(&d->scr_ll, i) {
             report_style_change_core(style, i);
         }
         d = lv_disp_get_next(d);
@@ -1247,7 +1247,7 @@ static void trans_anim_ready_cb(lv_anim_t * a)
      * It allows changing it by normal styles*/
     bool running = false;
     lv_style_trans_t * tr_i;
-    _LV_LL_READ(LV_GC_ROOT(_lv_obj_style_trans_ll), tr_i) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr_i) {
         if(tr_i != tr && tr_i->obj == tr->obj && tr_i->part == tr->part && tr_i->prop == tr->prop) {
             running = true;
         }
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index d0ad96b52..ce8119808 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -582,7 +582,8 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
 #endif
 
         lv_obj_t * i;
-        _LV_LL_READ(obj->child_ll, i) {
+        lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+        _LV_LL_READ(ll, i) {
             found_p = lv_refr_get_top_obj(area_p, i);
 
             /*If a children is ok then break*/
@@ -626,13 +627,14 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
 
     /*Do until not reach the screen*/
     while(par != NULL) {
+        lv_ll_t * ll = _lv_obj_get_child_ll(par);
         /*object before border_p has to be redrawn*/
-        lv_obj_t * i = _lv_ll_get_prev(&(par->child_ll), border_p);
+        lv_obj_t * i = _lv_ll_get_prev(ll, border_p);
 
         while(i != NULL) {
             /*Refresh the objects*/
             lv_refr_obj(i, mask_p);
-            i = _lv_ll_get_prev(&(par->child_ll), i);
+            i = _lv_ll_get_prev(ll, i);
         }
 
         /*Call the post draw design function of the parents of the to object*/
@@ -700,7 +702,8 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
             lv_area_t mask_child; /*Mask from obj and its child*/
             lv_obj_t * child_p;
             lv_area_t child_area;
-            _LV_LL_READ_BACK(obj->child_ll, child_p) {
+            lv_ll_t * ll = _lv_obj_get_child_ll(obj);
+            _LV_LL_READ_BACK(ll, child_p) {
                 lv_obj_get_coords(child_p, &child_area);
                 ext_size = child_p->ext_draw_pad;
                 child_area.x1 -= ext_size;
diff --git a/src/lv_draw/lv_img_decoder.c b/src/lv_draw/lv_img_decoder.c
index 895c064bb..e52a170b5 100644
--- a/src/lv_draw/lv_img_decoder.c
+++ b/src/lv_draw/lv_img_decoder.c
@@ -95,7 +95,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
 
     lv_res_t res = LV_RES_INV;
     lv_img_decoder_t * d;
-    _LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_img_defoder_ll), d) {
         res = LV_RES_INV;
         if(d->info_cb) {
             res = d->info_cb(d, src, header);
@@ -136,7 +136,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
     lv_res_t res = LV_RES_INV;
 
     lv_img_decoder_t * d;
-    _LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_img_defoder_ll), d) {
         /*Info an Open callbacks are required*/
         if(d->info_cb == NULL || d->open_cb == NULL) continue;
 
diff --git a/src/lv_hal/lv_hal_disp.c b/src/lv_hal/lv_hal_disp.c
index 3e7a33c67..352047f59 100644
--- a/src/lv_hal/lv_hal_disp.c
+++ b/src/lv_hal/lv_hal_disp.c
@@ -188,7 +188,7 @@ void lv_disp_drv_update(lv_disp_t * disp, lv_disp_drv_t * new_drv)
     memcpy(&disp->driver, new_drv, sizeof(lv_disp_drv_t));
 
     lv_obj_t * scr;
-    _LV_LL_READ(disp->scr_ll, scr) {
+    _LV_LL_READ(&disp->scr_ll, scr) {
         lv_obj_set_size(scr, lv_disp_get_hor_res(disp), lv_disp_get_ver_res(disp));
     }
 }
diff --git a/src/lv_misc/lv_anim.c b/src/lv_misc/lv_anim.c
index 4996eb8b1..f9b78fbe7 100644
--- a/src/lv_misc/lv_anim.c
+++ b/src/lv_misc/lv_anim.c
@@ -162,7 +162,7 @@ bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
 lv_anim_t * lv_anim_get(void * var, lv_anim_exec_xcb_t exec_cb)
 {
     lv_anim_t * a;
-    _LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) {
         if(a->var == var && a->exec_cb == exec_cb) {
             return a;
         }
@@ -179,7 +179,7 @@ uint16_t lv_anim_count_running(void)
 {
     uint16_t cnt = 0;
     lv_anim_t * a;
-    _LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) cnt++;
+    _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) cnt++;
 
     return cnt;
 }
@@ -444,7 +444,7 @@ static void anim_task(lv_task_t * param)
     (void)param;
 
     lv_anim_t * a;
-    _LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) {
         a->has_run = 0;
     }
 
diff --git a/src/lv_misc/lv_fs.c b/src/lv_misc/lv_fs.c
index 2a6a834bb..475fcab52 100644
--- a/src/lv_misc/lv_fs.c
+++ b/src/lv_misc/lv_fs.c
@@ -503,7 +503,7 @@ lv_fs_drv_t * lv_fs_get_drv(char letter)
 {
     lv_fs_drv_t * drv;
 
-    _LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_drv_ll), drv) {
         if(drv->letter == letter) {
             return drv;
         }
@@ -521,7 +521,7 @@ char * lv_fs_get_letters(char * buf)
     lv_fs_drv_t * drv;
     uint8_t i = 0;
 
-    _LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_drv_ll), drv) {
         buf[i] = drv->letter;
         i++;
     }
diff --git a/src/lv_misc/lv_ll.c b/src/lv_misc/lv_ll.c
index 4d3e4dabc..0b9d7df9b 100644
--- a/src/lv_misc/lv_ll.c
+++ b/src/lv_misc/lv_ll.c
@@ -156,6 +156,8 @@ void * _lv_ll_ins_tail(lv_ll_t * ll_p)
  */
 void _lv_ll_remove(lv_ll_t * ll_p, void * node_p)
 {
+    if(ll_p == NULL) return;
+
     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);
@@ -249,7 +251,27 @@ void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool h
     }
 }
 
+/**
+ * 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)
+{
+    if(ll_p == NULL) return NULL;
+    return ll_p->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)
+{
+    if(ll_p == NULL) return NULL;
+    return ll_p->tail;
+}
 /**
  * Return with the pointer of the next node after 'n_act'
  * @param ll_p pointer to linked list
diff --git a/src/lv_misc/lv_ll.h b/src/lv_misc/lv_ll.h
index 0fac6a713..812f840a6 100644
--- a/src/lv_misc/lv_ll.h
+++ b/src/lv_misc/lv_ll.h
@@ -98,20 +98,14 @@ void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool h
  * @param ll_p pointer to linked list
  * @return pointer to the head of 'll_p'
  */
-static inline void * _lv_ll_get_head(const lv_ll_t * ll_p)
-{
-    return ll_p->head;
-}
+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'
  */
-static inline void * _lv_ll_get_tail(const lv_ll_t * ll_p)
-{
-    return ll_p->tail;
-}
+void * _lv_ll_get_tail(const lv_ll_t * ll_p);
 
 /**
  * Return with the pointer of the next node after 'n_act'
@@ -163,9 +157,9 @@ bool _lv_ll_is_empty(lv_ll_t * ll_p);
  *      MACROS
  **********************/
 
-#define _LV_LL_READ(list, i) for(i = _lv_ll_get_head(&list); i != NULL; i = _lv_ll_get_next(&list, i))
+#define _LV_LL_READ(list, i) for((i) = _lv_ll_get_head(list); i != NULL; (i) = _lv_ll_get_next(list, i))
 
-#define _LV_LL_READ_BACK(list, i) for(i = _lv_ll_get_tail(&list); i != NULL; i = _lv_ll_get_prev(&list, i))
+#define _LV_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" */
diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index c41ea98eb..761440723 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -29,7 +29,7 @@
 #endif
 
 #ifndef LV_MEM_FULL_DEFRAG_CNT
-    #define LV_MEM_FULL_DEFRAG_CNT 32
+    #define LV_MEM_FULL_DEFRAG_CNT 64
 #endif
 
 #ifdef LV_ARCH_64
diff --git a/src/lv_misc/lv_task.c b/src/lv_misc/lv_task.c
index c051d9faa..c9b9837ae 100644
--- a/src/lv_misc/lv_task.c
+++ b/src/lv_misc/lv_task.c
@@ -305,7 +305,7 @@ void lv_task_set_prio(lv_task_t * task, lv_task_prio_t prio)
 
     /*Find the tasks with new priority*/
     lv_task_t * i;
-    _LV_LL_READ(LV_GC_ROOT(_lv_task_ll), i) {
+    _LV_LL_READ(&LV_GC_ROOT(_lv_task_ll), i) {
         if(i->prio <= prio) {
             if(i != task) _lv_ll_move_before(&LV_GC_ROOT(_lv_task_ll), task, i);
             break;
diff --git a/src/lv_themes/lv_theme_material.c b/src/lv_themes/lv_theme_material.c
index 31ad91d04..f8652378b 100644
--- a/src/lv_themes/lv_theme_material.c
+++ b/src/lv_themes/lv_theme_material.c
@@ -203,6 +203,7 @@ static bool inited;
 
 static void basic_init(void)
 {
+    style_init_reset(&styles->sb);
     lv_style_set_scrollbar_bg_opa(&styles->sb, LV_STATE_DEFAULT, LV_OPA_COVER);
     lv_style_set_scrollbar_bg_color(&styles->sb, LV_STATE_DEFAULT, (IS_LIGHT ? lv_color_hex(0xcccfd1) : lv_color_hex(0x777f85)));
     lv_style_set_scrollbar_radius(&styles->sb, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);

From 4fbc518d6a2b030f80d917ae7986652f390da968 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Thu, 29 Oct 2020 22:46:37 +0100
Subject: [PATCH 68/84] raname lv_obj_rare_attr_t to lv_obj_spec_attr_t and
 finialize it

---
 src/lv_core/lv_flex.c         |  75 +++++++++++----
 src/lv_core/lv_flex.h         |  12 ++-
 src/lv_core/lv_grid.c         |  50 ++++++----
 src/lv_core/lv_grid.h         |   2 +-
 src/lv_core/lv_group.c        |  19 ++--
 src/lv_core/lv_indev_scroll.c |  38 ++++----
 src/lv_core/lv_obj.c          | 176 ++++++++++++++--------------------
 src/lv_core/lv_obj.h          |  69 ++++++-------
 src/lv_core/lv_obj_draw.c     |   6 +-
 src/lv_core/lv_obj_pos.c      |  15 +--
 src/lv_core/lv_obj_scroll.c   |  80 +++++++++++-----
 src/lv_core/lv_obj_scroll.h   |  16 ++--
 src/lv_misc/lv_area.h         |  13 +++
 src/lv_misc/lv_mem.c          |  49 +++++-----
 src/lv_misc/lv_task.c         |   1 +
 15 files changed, 344 insertions(+), 277 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index d28e3f143..bf803179f 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -38,20 +38,25 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
 
 void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place)
 {
-    if(obj->flex_cont.dir == flex_dir && obj->flex_cont.place == flex_place) return;
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
 
-    obj->flex_cont.dir = flex_dir;
-    obj->flex_cont.place = flex_place;
+    if(obj->spec_attr->flex_cont.dir == flex_dir && obj->spec_attr->flex_cont.place == flex_place) return;
+
+    obj->spec_attr->flex_cont.dir = flex_dir & 0x3;
+    obj->spec_attr->flex_cont.wrap = flex_dir & LV_FLEX_WRAP ? 1 : 0;
+    obj->spec_attr->flex_cont.rev = flex_dir & LV_FLEX_REVERSE ? 1 : 0;
+    obj->spec_attr->flex_cont.place = flex_place;
 
     _lv_flex_refresh(obj);
 }
 
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
 {
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
 
-    if(obj->flex_cont.gap == gap) return;
+    if(obj->spec_attr->flex_cont.gap == gap) return;
 
-    obj->flex_cont.gap = gap;
+    obj->spec_attr->flex_cont.gap = gap;
 
     _lv_flex_refresh(obj);
 }
@@ -62,21 +67,52 @@ void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
     lv_obj_set_pos(obj, f, f);
 }
 
+lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.dir;
+    else return LV_FLEX_DIR_NONE;
+}
+
+lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.place;
+    else return LV_FLEX_START;
+}
+
+bool lv_obj_get_flex_wrap(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.wrap;
+    else return false;
+}
+
+bool lv_obj_get_flex_reverse(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.rev;
+    else return false;
+}
+
+lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.gap;
+    else return 0;
+}
+
 void _lv_flex_refresh(lv_obj_t * cont)
 {
-    if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return;
+    lv_flex_dir_t dir = lv_obj_get_flex_dir(cont);
+
+    if(dir == LV_FLEX_DIR_NONE) return;
 
-    lv_flex_dir_t dir = cont->flex_cont.dir & 0x3;
     bool row = dir == LV_FLEX_DIR_ROW ? true : false;
     /*Count the grow units and free space*/
     lv_coord_t max_main_size = (row ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
 
+    lv_coord_t place = lv_obj_get_flex_place(cont);
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
 
-    lv_coord_t place = cont->flex_cont.place;
     if((row && cont->h_set == LV_SIZE_AUTO) ||
        (!row && cont->w_set == LV_SIZE_AUTO))
     {
@@ -90,7 +126,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t track_size;
     lv_obj_t * track_first_item;
     lv_obj_t * next_track_first_item;
-    bool rev = cont->flex_cont.dir & LV_FLEX_REVERSE;
+    bool rev = lv_obj_get_flex_reverse(cont);
 
     if(place != LV_FLEX_START) {
         track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
@@ -117,6 +153,8 @@ void _lv_flex_refresh(lv_obj_t * cont)
         track_first_item = next_track_first_item;
         *cross_pos += track_size + gap;
     }
+    LV_ASSERT_MEM_INTEGRITY();
+
 }
 
 /**********************
@@ -125,18 +163,18 @@ void _lv_flex_refresh(lv_obj_t * cont)
 
 static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
 {
-    lv_flex_dir_t dir = cont->flex_cont.dir;
-    bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
+    bool wrap = lv_obj_get_flex_wrap(cont);
+    bool rev = lv_obj_get_flex_reverse(cont);
+    lv_coord_t gap = lv_obj_get_flex_gap(cont);
+    bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
     lv_coord_t(*get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
-    void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
-    bool wrap = dir & LV_FLEX_WRAP ? true : false;
+    void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
 
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
 
     lv_coord_t grow_sum = 0;
     lv_coord_t used_size = 0;
-    lv_coord_t gap = cont->flex_cont.gap;
     uint32_t grow_item_cnt = 0;
     *track_cross_size = 0;
     *grow_unit = 0;
@@ -186,18 +224,19 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
 
 static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
 {
-    lv_flex_dir_t dir = cont->flex_cont.dir;
-    bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
+    bool rev = lv_obj_get_flex_reverse(cont);
+    lv_coord_t gap = lv_obj_get_flex_gap(cont);
+    bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
+
     lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (row ? lv_area_set_width : lv_area_set_height);
     lv_coord_t (*area_get_main_size)(const lv_area_t *) = (!row ? lv_area_get_width : lv_area_get_height);
     lv_style_int_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
     lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
-    void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
+    void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
 
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
-    lv_coord_t gap = cont->flex_cont.gap;
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
     lv_obj_t * item = item_first;   /*Just to use a shorter name*/
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 884300f4a..86787d271 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -48,8 +48,10 @@ typedef enum {
 
 typedef struct {
     lv_coord_t gap;
-    uint32_t place      :4;
-    uint32_t dir        :4;
+    uint8_t dir        :2;
+    uint8_t wrap       :1;
+    uint8_t rev        :1;
+    uint8_t place      :3;
 }lv_flex_cont_t;
 
 /**********************
@@ -59,6 +61,12 @@ typedef struct {
 void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place);
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap);
 void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
+
+lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj);
+lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj);
+bool lv_obj_get_flex_wrap(const lv_obj_t * obj);
+bool lv_obj_get_flex_reverse(const lv_obj_t * obj);
+lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj);
 void _lv_flex_refresh(lv_obj_t * cont);
 
 /**********************
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index dfbe1434e..49ceed944 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -53,7 +53,9 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    obj->grid = grid;
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->grid = grid;
+
     _lv_grid_full_refresh(obj);
 }
 
@@ -62,11 +64,12 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
  * @param obj pointer to an object
  * @return the grid, NULL if no grid
  */
-const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid)
+const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return obj->grid;
+    if(obj->spec_attr) return obj->spec_attr->grid;
+    return NULL;
 }
 
 
@@ -96,9 +99,10 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
  */
 void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
 {
-    if(cont->grid == NULL) return;
-    if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) return;
-    if(cont->grid->col_dsc_len == 0 || cont->grid->row_dsc_len == 0) return;
+    lv_grid_t * g = lv_obj_get_grid(cont);
+    if(g == NULL) return;
+    if(g->col_dsc == NULL || g->row_dsc == NULL) return;
+    if(g->col_dsc_len == 0 || g->row_dsc_len == 0) return;
 
     if(lv_obj_get_child(cont, NULL) == NULL) {
         _lv_memset_00(calc_out, sizeof(_lv_grid_calc_t));
@@ -111,11 +115,11 @@ void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
 
     bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
-    calc_out->grid_w = grid_place(cont_w, auto_w, cont->grid->col_place, cont->grid->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
+    calc_out->grid_w = grid_place(cont_w, auto_w, g->col_place, g->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
 
     bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
     lv_coord_t cont_h = lv_obj_get_height_fit(cont);
-    calc_out->grid_h = grid_place(cont_h, auto_h, cont->grid->row_place, cont->grid->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
+    calc_out->grid_h = grid_place(cont_h, auto_h, g->row_place, g->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
 
     LV_ASSERT_MEM_INTEGRITY();
 }
@@ -139,12 +143,12 @@ void _lv_grid_calc_free(_lv_grid_calc_t * calc)
  */
 bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
 {
-    if(obj->grid == NULL) return false;
-    if(obj->grid->col_dsc == NULL)  return false;
+    lv_grid_t * g = lv_obj_get_grid(obj);
+    if(g->col_dsc == NULL)  return false;
 
     uint32_t i;
-    for(i = 0; i < obj->grid->col_dsc_len; i++) {
-        if(LV_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
+    for(i = 0; i < g->col_dsc_len; i++) {
+        if(LV_GRID_IS_FR(g->col_dsc[i])) return true;
     }
 
     return false;
@@ -157,12 +161,13 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
  */
 bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
 {
-    if(obj->grid == NULL) return false;
-    if(obj->grid->row_dsc == NULL)  return false;
+    lv_grid_t * g = lv_obj_get_grid(obj);
+    if(g == NULL) return false;
+    if(g->row_dsc == NULL)  return false;
 
     uint32_t i;
-    for(i = 0; i < obj->grid->row_dsc_len; i++) {
-        if(LV_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
+    for(i = 0; i < g->row_dsc_len; i++) {
+        if(LV_GRID_IS_FR(g->row_dsc[i])) return true;
     }
 
     return false;
@@ -175,7 +180,7 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
 void _lv_grid_full_refresh(lv_obj_t * cont)
 {
     /*Calculate the grid*/
-    if(cont->grid == NULL) return;
+    if(lv_obj_get_grid(cont) == NULL) return;
     _lv_grid_calc_t calc;
     _lv_grid_calc(cont, &calc);
 
@@ -213,7 +218,8 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
     /*Calculate the grid*/
     lv_obj_t * cont = lv_obj_get_parent(item);
     if(cont == NULL) return;
-    if(cont->grid == NULL) return;
+    if(cont->spec_attr == NULL) return;
+    if(cont->spec_attr->grid == NULL) return;
     _lv_grid_calc_t calc;
     _lv_grid_calc(cont, &calc);
 
@@ -228,7 +234,7 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
 
 static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
-    const lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->spec_attr->grid;
     uint32_t i;
 
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
@@ -267,7 +273,7 @@ static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
 
 static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
 {
-    const lv_grid_t * grid = cont->grid;
+    const lv_grid_t * grid = cont->spec_attr->grid;
     uint32_t i;
 
     calc->row_num = grid->row_dsc_len;
@@ -466,7 +472,9 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
  */
 static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj)
 {
-    if(obj->grid == grid || (obj->grid && grid == NULL)) _lv_grid_full_refresh(obj);
+    if(obj->spec_attr) {
+        if(obj->spec_attr->grid == grid || (obj->spec_attr->grid && grid == NULL)) _lv_grid_full_refresh(obj);
+    }
 
     lv_obj_t * child = lv_obj_get_child(obj, NULL);
     while(child) {
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index 4b1b6cc5a..e9c25b2f0 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -101,7 +101,7 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid);
  * @param obj pointer to an object
  * @return the grid, NULL if no grid
  */
-const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid);
+const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj);
 
 
 /**
diff --git a/src/lv_core/lv_group.c b/src/lv_core/lv_group.c
index 32f906dc5..571ac30ff 100644
--- a/src/lv_core/lv_group.c
+++ b/src/lv_core/lv_group.c
@@ -93,7 +93,7 @@ void lv_group_del(lv_group_t * group)
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
     _LV_LL_READ(&group->obj_ll, obj) {
-        (*obj)->group_p = NULL;
+        if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
     }
 
     _lv_ll_clear(&(group->obj_ll));
@@ -119,15 +119,18 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
     }
 
     /*If the object is already in a group and focused then defocus it*/
-    if(obj->group_p) {
+    lv_group_t * group_cur = lv_obj_get_group(obj);
+    if(group_cur) {
         if(lv_obj_is_focused(obj)) {
-            lv_group_refocus(obj->group_p);
+            lv_group_refocus(group_cur);
 
             LV_LOG_INFO("lv_group_add_obj: assign object to an other group");
         }
     }
 
-    obj->group_p     = group;
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->group_p = group;
+
     lv_obj_t ** next = _lv_ll_ins_tail(&group->obj_ll);
     LV_ASSERT_MEM(next);
     if(next == NULL) return;
@@ -146,7 +149,7 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
  */
 void lv_group_remove_obj(lv_obj_t * obj)
 {
-    lv_group_t * g = obj->group_p;
+    lv_group_t * g = lv_obj_get_group(obj);
     if(g == NULL) return;
     if(g->obj_focus == NULL) return; /*Just to be sure (Not possible if there is at least one object in the group)*/
 
@@ -177,7 +180,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
         if(*i == obj) {
             _lv_ll_remove(&g->obj_ll, i);
             lv_mem_free(i);
-            obj->group_p = NULL;
+            if(obj->spec_attr) obj->spec_attr->group_p = NULL;
             break;
         }
     }
@@ -199,7 +202,7 @@ void lv_group_remove_all_objs(lv_group_t * group)
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
     _LV_LL_READ(&group->obj_ll, obj) {
-        (*obj)->group_p = NULL;
+        if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
     }
 
     _lv_ll_clear(&(group->obj_ll));
@@ -212,7 +215,7 @@ void lv_group_remove_all_objs(lv_group_t * group)
 void lv_group_focus_obj(lv_obj_t * obj)
 {
     if(obj == NULL) return;
-    lv_group_t * g = obj->group_p;
+    lv_group_t * g = lv_obj_get_group(obj);
     if(g == NULL) return;
 
     if(g->frozen != 0) return;
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index c9f97e319..4a8518c8e 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -81,10 +81,11 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
             diff_y = elastic_diff(scroll_obj, proc->types.pointer.vect.y, st, sb);
         }
 
-        if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
-        if((scroll_obj->scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
+        lv_dir_t scroll_dir = lv_obj_get_scroll_dir(scroll_obj);
+        if((scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
+        if((scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
+        if((scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
+        if((scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
 
         /*Respect the scroll limit area*/
         scroll_limit_diff(proc, &diff_x, &diff_y);
@@ -115,10 +116,13 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
         proc->types.pointer.scroll_throw_vect.x = 0;
     }
 
+    lv_scroll_snap_align_t align_x = lv_obj_get_snap_align_x(scroll_obj);
+    lv_scroll_snap_align_t align_y = lv_obj_get_snap_align_y(scroll_obj);
+
     if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
         proc->types.pointer.scroll_throw_vect.x = 0;
         /*If no snapping "throw"*/
-        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+        if(align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
             proc->types.pointer.scroll_throw_vect.y =
                     proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
 
@@ -141,7 +145,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
     else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
         proc->types.pointer.scroll_throw_vect.y = 0;
         /*If no snapping "throw"*/
-        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+        if(align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
             proc->types.pointer.scroll_throw_vect.x =
                     proc->types.pointer.scroll_throw_vect.x * (100 - scroll_throw) / 100;
 
@@ -166,7 +170,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
     if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
         /*Revert if scrolled in*/
         /*If vertically scrollable and not controlled by snap*/
-        if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
+        if(align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
             lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
             if(st > 0 || sb > 0) {
@@ -180,7 +184,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
         }
 
         /*If horizontally scrollable and not controlled by snap*/
-        if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
+        if(align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
             lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
             lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
             if (sl > 0 || sr > 0) {
@@ -276,7 +280,7 @@ static lv_obj_t * find_scroll_obj(lv_indev_proc_t * proc)
         bool right_en = hor_en;
 
         /*The object might have disabled some directions.*/
-        lv_dir_t scroll_dir = obj_act->scroll_dir;
+        lv_dir_t scroll_dir = lv_obj_get_scroll_dir(obj_act);
         if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
         if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
         if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
@@ -347,7 +351,7 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
     }
     /*With STOP limit the scrolling to the perv and next snap point*/
     else {
-        switch(obj->snap_align_y) {
+        switch(lv_obj_get_snap_align_y(obj)) {
         case LV_SCROLL_SNAP_ALIGN_START:
             proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
             proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
@@ -368,7 +372,7 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
             break;
         }
 
-        switch(obj->snap_align_x) {
+        switch(lv_obj_get_snap_align_x(obj)) {
         case LV_SCROLL_SNAP_ALIGN_START:
             proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
             proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
@@ -399,7 +403,8 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
 
 static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
 {
-    if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+    lv_scroll_snap_align_t align = lv_obj_get_snap_align_x(obj);
+    if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
 
     lv_coord_t dist = LV_COORD_MAX;
 
@@ -408,7 +413,7 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
         if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
             lv_coord_t x_child = 0;
             lv_coord_t x_parent = 0;
-            switch(obj->snap_align_x) {
+            switch(align) {
             case LV_SCROLL_SNAP_ALIGN_START:
                 x_child = child->coords.x1;
                 x_parent = obj->coords.x1;
@@ -431,7 +436,6 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
 
         child = lv_obj_get_child_back(obj, child);
     }
-    LV_ASSERT_MEM_INTEGRITY();
 
     return dist == LV_COORD_MAX ? 0: -dist;
 }
@@ -447,7 +451,8 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
  */
 static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
 {
-    if(obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
+    lv_scroll_snap_align_t align = lv_obj_get_snap_align_y(obj);
+    if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
 
     lv_coord_t dist = LV_COORD_MAX;
 
@@ -456,7 +461,7 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
         if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
             lv_coord_t y_child = 0;
             lv_coord_t y_parent = 0;
-            switch(obj->snap_align_y) {
+            switch(align) {
             case LV_SCROLL_SNAP_ALIGN_START:
                 y_child = child->coords.y1;
                 y_parent = obj->coords.y1;
@@ -480,7 +485,6 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
         child = lv_obj_get_child_back(obj, child);
     }
 
-    LV_ASSERT_MEM_INTEGRITY();
     return dist == LV_COORD_MAX ? 0 : -dist;
 }
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 427618dfa..ae1259995 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -204,16 +204,9 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
         _lv_memset_00(new_obj, sizeof(lv_obj_t));
 
-#if LV_USE_BIDI
-        new_obj->base_dir     = LV_BIDI_BASE_DIR_DEF;
-#else
-        new_obj->base_dir     = LV_BIDI_DIR_LTR;
-#endif
-
         /*Set the callbacks*/
         new_obj->signal_cb = lv_obj_signal;
         new_obj->design_cb = lv_obj_design;
-        new_obj->event_cb = NULL;
 
         /*Set coordinates to full screen size*/
         new_obj->coords.x1    = 0;
@@ -225,10 +218,10 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     else {
         LV_LOG_TRACE("Object create started");
         LV_ASSERT_OBJ(parent, LV_OBJX_NAME);
-        if(parent->rare_attr == NULL) {
-            parent->rare_attr = lv_obj_allocate_rare_attr(parent);
+        if(parent->spec_attr == NULL) {
+            parent->spec_attr = lv_obj_allocate_rare_attr(parent);
         }
-        new_obj = _lv_ll_ins_head(&parent->rare_attr->child_ll);
+        new_obj = _lv_ll_ins_head(&parent->spec_attr->child_ll);
         LV_ASSERT_MEM(new_obj);
         if(new_obj == NULL) return NULL;
 
@@ -236,16 +229,9 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
         new_obj->parent = parent;
 
-#if LV_USE_BIDI
-        new_obj->base_dir     = LV_BIDI_DIR_INHERIT;
-#else
-        new_obj->base_dir     = LV_BIDI_DIR_LTR;
-#endif
-
         /*Set the callbacks (signal:cb is required in `lv_obj_get_base_dir` if `LV_USE_ASSERT_OBJ` is enabled)*/
         new_obj->signal_cb = lv_obj_signal;
         new_obj->design_cb = lv_obj_design;
-        new_obj->event_cb = NULL;
 
         new_obj->coords.y1    = parent->coords.y1;
         new_obj->coords.y2    = parent->coords.y1 + LV_OBJ_DEF_HEIGHT;
@@ -264,25 +250,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
     new_obj->ext_draw_pad = 0;
 
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    _lv_memset_00(&new_obj->ext_click_pad, sizeof(new_obj->ext_click_pad));
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    new_obj->ext_click_pad = 0;
-#endif
-
-    /*Init. user date*/
-#if LV_USE_USER_DATA
-    _lv_memset_00(&new_obj->user_data, sizeof(lv_obj_user_data_t));
-#endif
-
-
-#if LV_USE_GROUP
-    new_obj->group_p = NULL;
-#endif
-
     /*Set attributes*/
-    new_obj->scroll_mode  = LV_SCROLL_MODE_AUTO;
-    new_obj->scroll_dir  = LV_DIR_ALL;
     new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
     new_obj->flags |= LV_OBJ_FLAG_SNAPABLE;
     new_obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
@@ -309,26 +277,12 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
          lv_area_copy(&new_obj->coords, &copy->coords);
          new_obj->ext_draw_pad = copy->ext_draw_pad;
 
- #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-         lv_area_copy(&new_obj->ext_click_pad, &copy->ext_click_pad);
- #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-         new_obj->ext_click_pad = copy->ext_click_pad;
- #endif
-
-         /*Set user data*/
- #if LV_USE_USER_DATA
-         _lv_memcpy(&new_obj->user_data, &copy->user_data, sizeof(lv_obj_user_data_t));
- #endif
-         /*Only copy the `event_cb`. `signal_cb` and `design_cb` will be copied in the derived
-          * object type (e.g. `lv_btn`)*/
-         new_obj->event_cb = copy->event_cb;
-
          new_obj->flags  = copy->flags;
 
  #if LV_USE_GROUP
          /*Add to the same group*/
-         if(copy->group_p != NULL) {
-             lv_group_add_obj(copy->group_p, new_obj);
+         if(copy->spec_attr && copy->spec_attr->group_p) {
+             lv_group_add_obj(copy->spec_attr->group_p, new_obj);
          }
  #endif
 
@@ -559,8 +513,8 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
 
     lv_obj_invalidate(obj);
 
-    if(parent->rare_attr == NULL) {
-        parent->rare_attr = lv_obj_allocate_rare_attr(parent);
+    if(parent->spec_attr == NULL) {
+        parent->spec_attr = lv_obj_allocate_rare_attr(parent);
     }
 
     lv_obj_t * old_par = obj->parent;
@@ -667,12 +621,14 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    obj->ext_click_pad.x1 = left;
-    obj->ext_click_pad.x2 = right;
-    obj->ext_click_pad.y1 = top;
-    obj->ext_click_pad.y2 = bottom;
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    objrare_attr->->ext_click_pad.x1 = left;
+    objrare_attr->->ext_click_pad.x2 = right;
+    objrare_attr->->ext_click_pad.y1 = top;
+    objrare_attr->->ext_click_pad.y2 = bottom;
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    obj->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
 #else
     LV_UNUSED(obj);
     LV_UNUSED(left);
@@ -704,7 +660,8 @@ void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir)
         return;
     }
 
-    obj->base_dir = dir;
+    lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->base_dir = dir;
     lv_signal_send(obj, LV_SIGNAL_BASE_DIR_CHG, NULL);
 
     /* Notify the children about the parent base dir has changed.
@@ -841,8 +798,9 @@ void lv_obj_clear_state(lv_obj_t * obj, lv_state_t state)
 void lv_obj_set_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+    if(obj->spec_attr == NULL) obj->spec_attr = lv_obj_allocate_rare_attr(obj);
 
-    obj->event_cb = event_cb;
+    obj->spec_attr->event_cb = event_cb;
 }
 
 /**
@@ -859,7 +817,7 @@ lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     lv_res_t res;
-    res = lv_event_send_func(obj->event_cb, obj, event, data);
+    res = lv_event_send_func(lv_obj_get_event_cb(obj), obj, event, data);
     return res;
 }
 
@@ -1052,21 +1010,27 @@ void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size)
  * @return pointer to the allocated ext.
  * If out of memory NULL is returned and the original ext is preserved
  */
-lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
+lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
 
-    if(obj->rare_attr == NULL) {
-        obj->rare_attr = lv_mem_realloc(obj->ext_attr, sizeof(lv_obj_rare_attr_t));
-        LV_ASSERT_MEM(obj->rare_attr);
-        if(obj->rare_attr == NULL) return NULL;
+    if(obj->spec_attr == NULL) {
+        static uint32_t x = 0;
+        x++;
+        obj->spec_attr = lv_mem_alloc(sizeof(lv_obj_spec_attr_t));
+        LV_ASSERT_MEM(obj->spec_attr);
+        if(obj->spec_attr == NULL) return NULL;
 
-        _lv_memset_00(obj->rare_attr, sizeof(lv_obj_rare_attr_t));
-        _lv_ll_init(&(obj->rare_attr->child_ll), sizeof(lv_obj_t));
+        _lv_memset_00(obj->spec_attr, sizeof(lv_obj_spec_attr_t));
+        _lv_ll_init(&(obj->spec_attr->child_ll), sizeof(lv_obj_t));
+
+        obj->spec_attr->scroll_dir = LV_DIR_ALL;
+        obj->spec_attr->base_dir = LV_BIDI_DIR_INHERIT;
+        obj->spec_attr->scroll_mode = LV_SCROLL_MODE_AUTO;
 
     }
-    return obj->rare_attr;
+    return obj->spec_attr;
 }
 
 
@@ -1272,7 +1236,8 @@ lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir)
     return 0;
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
     LV_UNUSED(dir);
-    return obj->ext_click_pad;
+    if(obj->spec_attr) return obj->spec_attr->ext_click_pad;
+    else return 0;
 #else
     switch(dir) {
     case LV_DIR_LEFT:
@@ -1299,28 +1264,17 @@ lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir)
  */
 bool _lv_obj_is_click_point_on(lv_obj_t * obj, const lv_point_t * point)
 {
-#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
-#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    lv_area_t ext_area;
-    ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
-    ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
-    ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
-    ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
-
-    if(!_lv_area_is_point_on(&ext_area, point, 0)) {
+#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_OFF
+    return _lv_area_is_point_on(&obj->coords, point, 0);
 #else
-    if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
+    lv_area_t ext_area;
+    ext_area.x1 = obj->coords.x1 - lv_obj_get_ext_click_area(obj, LV_DIR_LEFT);
+    ext_area.x2 = obj->coords.x2 + lv_obj_get_ext_click_area(obj, LV_DIR_RIGHT);
+    ext_area.y1 = obj->coords.y1 - lv_obj_get_ext_click_area(obj, LV_DIR_TOP);
+    ext_area.y2 = obj->coords.y2 + lv_obj_get_ext_click_area(obj, LV_DIR_BOTTOM);
+
+    return _lv_area_is_point_on(&ext_area, point, 0);
 #endif
-        return false;
-    }
-    return true;
 }
 
 /**
@@ -1362,11 +1316,15 @@ lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
+    if(obj->spec_attr == NULL) return LV_BIDI_DIR_LTR;
 #if LV_USE_BIDI
     const lv_obj_t * parent = obj;
 
     while(parent) {
-        if(parent->base_dir != LV_BIDI_DIR_INHERIT) return parent->base_dir;
+        /*If the base dir set use it. If not set assume INHERIT so got the next parent*/
+        if(parent->spec_attr) {
+            if(parent->spec_attr->base_dir != LV_BIDI_DIR_INHERIT) return parent->spec_attr->base_dir;
+        }
 
         parent = lv_obj_get_parent(parent);
     }
@@ -1418,7 +1376,8 @@ lv_event_cb_t lv_obj_get_event_cb(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return obj->event_cb;
+    if(obj->spec_attr) return obj->spec_attr->event_cb;
+    else return NULL;
 }
 
 /*------------------
@@ -1477,9 +1436,10 @@ void lv_obj_get_type(const lv_obj_t * obj, lv_obj_type_t * buf)
  */
 lv_obj_user_data_t lv_obj_get_user_data(const lv_obj_t * obj)
 {
+    static lv_obj_user_data_t empty = {0};
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->user_data;
+    if(obj->spec_attr) return obj->spec_attr->user_data;
+    else return empty;
 }
 
 /**
@@ -1491,7 +1451,8 @@ lv_obj_user_data_t * lv_obj_get_user_data_ptr(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    return (lv_obj_user_data_t *)&obj->user_data;
+    if(obj->spec_attr) return obj->spec_attr->user_data;
+    return &obj->spec_attr->user_data;
 }
 
 /**
@@ -1503,7 +1464,8 @@ void lv_obj_set_user_data(lv_obj_t * obj, lv_obj_user_data_t data)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    _lv_memcpy(&obj->user_data, &data, sizeof(lv_obj_user_data_t));
+    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    _lv_memcpy(&obj->spec_attr->user_data, &data, sizeof(lv_obj_user_data_t));
 }
 #endif
 
@@ -1517,7 +1479,8 @@ void * lv_obj_get_group(const lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
 #if LV_USE_GROUP
-    return obj->group_p;
+    if(obj->spec_attr) return obj->spec_attr->group_p;
+    else return NULL;
 #else
     LV_UNUSED(obj);
     return NULL;
@@ -1534,8 +1497,9 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
 #if LV_USE_GROUP
-    if(obj->group_p) {
-        if(lv_group_get_focused(obj->group_p) == obj) return true;
+    lv_group_t * g = lv_obj_get_group(obj);
+    if(g) {
+        if(lv_group_get_focused(g) == obj) return true;
     }
     return false;
 #else
@@ -1565,7 +1529,7 @@ bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str)
 
 lv_ll_t * _lv_obj_get_child_ll(const lv_obj_t * obj)
 {
-    if(obj->rare_attr) return &obj->rare_attr->child_ll;
+    if(obj->spec_attr) return &obj->spec_attr->child_ll;
     else return NULL;
 }
 
@@ -1840,7 +1804,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
 
 #if GRID_DEBUG
         /*Draw the grid cells*/
-        if(obj->grid) {
+        if(lv_obj_get_grid(obj)) {
             _lv_grid_calc_t calc;
             _lv_grid_calc(obj, &calc);
 
@@ -1887,7 +1851,7 @@ static void base_dir_refr_children(lv_obj_t * obj)
 {
     lv_obj_t * child;
     _LV_LL_READ(_lv_obj_get_child_ll(obj), child) {
-        if(child->base_dir == LV_BIDI_DIR_INHERIT) {
+        if(lv_obj_get_base_dir(child) == LV_BIDI_DIR_INHERIT) {
             lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
             base_dir_refr_children(child);
         }
@@ -2006,8 +1970,8 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
                     lv_obj_set_size(child, child->w_set, child->h_set);
                 }
             }
-            if(obj->grid) _lv_grid_full_refresh(obj);
-            if(obj->flex_cont.dir) _lv_flex_refresh(obj);
+            if(lv_obj_get_grid(obj)) _lv_grid_full_refresh(obj);
+            if(lv_obj_get_flex_dir(obj) != LV_FLEX_DIR_NONE) _lv_flex_refresh(obj);
         }
     }
     else if(sign == LV_SIGNAL_CHILD_CHG) {
@@ -2020,7 +1984,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
 
         /*If the changed children was a grid item refresh this objects grid*/
-        if(obj->grid) {
+        if(lv_obj_get_grid(obj)) {
             lv_obj_t * child = param;
             if(child) {
                 if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
@@ -2046,7 +2010,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
 
-        if(obj->grid) _lv_grid_full_refresh(obj);
+        if(lv_obj_get_grid(obj)) _lv_grid_full_refresh(obj);
 
         /*Reposition non grid objects on by one*/
         lv_obj_t * child;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 5fcdb9ce0..65fc1e055 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -169,20 +169,6 @@ enum {
 
 typedef uint8_t lv_state_t;
 
-enum {
-    LV_DIR_NONE     = 0x00,
-    LV_DIR_LEFT     = (1 << 0),
-    LV_DIR_RIGHT    = (1 << 1),
-    LV_DIR_TOP      = (1 << 2),
-    LV_DIR_BOTTOM   = (1 << 3),
-    LV_DIR_HOR      = LV_DIR_LEFT | LV_DIR_RIGHT,
-    LV_DIR_VER      = LV_DIR_TOP | LV_DIR_BOTTOM,
-    LV_DIR_ALL      = LV_DIR_HOR | LV_DIR_VER,
-};
-
-typedef uint8_t lv_dir_t;
-
-
 enum {
     LV_OBJ_FLAG_HIDDEN          = (1 << 0),
     LV_OBJ_FLAG_CLICKABLE       = (1 << 1),
@@ -210,22 +196,21 @@ typedef uint16_t lv_obj_flag_t;
 
 typedef struct {
     lv_ll_t child_ll;       /**< Linked list to store the children objects*/
-    lv_point_t scroll; /**< The current X/Y scroll offset*/
-}lv_obj_rare_attr_t;
 
+#if LV_USE_GROUP != 0
+    void * group_p;
+#endif
 
-struct _lv_obj_t {
-    lv_obj_rare_attr_t * rare_attr;
-    struct _lv_obj_t * parent; /**< Pointer to the parent object*/
+#if LV_USE_USER_DATA
+    lv_obj_user_data_t user_data; /**< Custom user data for object. */
+#endif
 
-    lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
+    const lv_grid_t * grid;
 
     lv_event_cb_t event_cb; /**< Event callback function */
-    lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
-    lv_design_cb_t design_cb; /**< Object type specific design function*/
 
-    void * ext_attr;            /**< Object type specific extended data*/
-    lv_style_list_t  style_list;
+    lv_flex_cont_t flex_cont;
+    lv_point_t scroll; /**< The current X/Y scroll offset*/
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
     uint8_t ext_click_pad; /**< Extra click padding in all direction */
@@ -233,15 +218,28 @@ struct _lv_obj_t {
     lv_area_t ext_click_pad;   /**< Extra click padding area. */
 #endif
 
-    lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
-
-    /*Attributes and states*/
-    lv_obj_flag_t flags;
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
     lv_scroll_snap_align_t snap_align_x : 2;
     lv_scroll_snap_align_t snap_align_y : 2;
     lv_scroll_dir_t scroll_dir :4;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
+}lv_obj_spec_attr_t;
+
+
+struct _lv_obj_t {
+    lv_obj_spec_attr_t * spec_attr;
+    struct _lv_obj_t * parent; /**< Pointer to the parent object*/
+
+    lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
+
+    lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
+    lv_design_cb_t design_cb; /**< Object type specific design function*/
+
+    void * ext_attr;            /**< Object type specific extended data*/
+    lv_style_list_t  style_list;
+
+    /*Attributes and states*/
+    lv_obj_flag_t flags;
 
     lv_state_t state;
 
@@ -250,18 +248,7 @@ struct _lv_obj_t {
     lv_coord_t w_set;
     lv_coord_t h_set;
 
-#if LV_USE_GROUP != 0
-    void * group_p;
-#endif
-
-
-#if LV_USE_USER_DATA
-    lv_obj_user_data_t user_data; /**< Custom user data for object. */
-#endif
-
-    const lv_grid_t * grid;
-
-    lv_flex_cont_t flex_cont;
+    lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 };
 
 enum {
@@ -553,7 +540,7 @@ void lv_obj_set_design_cb(lv_obj_t * obj, lv_design_cb_t design_cb);
  */
 void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size);
 
-lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
+lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
 /*=======================
  * Getter functions
  *======================*/
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index ac356a140..2481bc7c5 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -437,8 +437,10 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t obj_h = lv_obj_get_height(obj);
     lv_coord_t obj_w = lv_obj_get_width(obj);
 
+    lv_scroll_dir_t dir = lv_obj_get_scroll_dir(obj);
+
     bool ver_draw = false;
-    if((obj->scroll_dir & LV_DIR_VER) &&
+    if((dir & LV_DIR_VER) &&
        ((sm == LV_SCROLL_MODE_ON) ||
         (sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
         (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER))) {
@@ -447,7 +449,7 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
 
 
     bool hor_draw = false;
-    if((obj->scroll_dir & LV_DIR_HOR) &&
+    if((dir & LV_DIR_HOR) &&
           ((sm == LV_SCROLL_MODE_ON) ||
            (sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
            (sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR))) {
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 8aaabcdb1..d6392ed5b 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -593,7 +593,7 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
     /*Get the grid size of the object has a defined grid*/
     lv_coord_t grid_w = 0;
     lv_coord_t grid_h = 0;
-    if(obj->grid) {
+    if(lv_obj_get_grid(obj)) {
         _lv_grid_calc_t calc;
         _lv_grid_calc(obj, &calc);
         grid_w = calc.grid_w + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
@@ -714,11 +714,12 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
 {
     lv_obj_t * cont = lv_obj_get_parent(obj);
     if(cont == NULL) return false;
-    if(cont->grid == NULL) return false;
-    if(cont->grid->col_dsc == NULL) return false;
-    if(cont->grid->row_dsc == NULL) return false;
-    if(cont->grid->row_dsc_len == 0) return false;
-    if(cont->grid->col_dsc_len == 0) return false;
+    const lv_grid_t * g = lv_obj_get_grid(obj);
+    if(g == NULL) return false;
+    if(g->col_dsc == NULL) return false;
+    if(g->row_dsc == NULL) return false;
+    if(g->row_dsc_len == 0) return false;
+    if(g->col_dsc_len == 0) return false;
     if(LV_COORD_IS_GRID(obj->x_set) == false || LV_COORD_IS_GRID(obj->y_set) == false) return false;
     return true;
 }
@@ -733,7 +734,7 @@ bool _lv_obj_is_flex_item(struct _lv_obj_t * obj)
 {
     lv_obj_t * cont = lv_obj_get_parent(obj);
     if(cont == NULL) return false;
-    if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return false;
+    if(lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_NONE) return false;
     if(LV_COORD_IS_FLEX(obj->x_set) == false || LV_COORD_IS_FLEX(obj->y_set) == false) return false;
     return true;
 }
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index a192ed4ad..6fb485754 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -47,23 +47,13 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(obj->scroll_mode == mode) return;
-    obj->scroll_mode = mode;
+    lv_obj_allocate_rare_attr(obj);
+
+    if(obj->spec_attr->scroll_mode == mode) return;
+    obj->spec_attr->scroll_mode = mode;
     lv_obj_invalidate(obj);
 }
 
-/**
- * Get how the scrollbars should behave.
- * @param obj pointer to an object
- * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
-lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    return obj->scroll_mode;
-}
-
 /**
  * Moves all children with horizontally or vertically.
  * It doesn't take into account any limits so any values are possible
@@ -75,11 +65,11 @@ void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 {
     if(x == 0 && y == 0) return;
 
-    if(obj->rare_attr == NULL) {
-        obj->rare_attr = lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) {
+        obj->spec_attr = lv_obj_allocate_rare_attr(obj);
     }
-    obj->rare_attr->scroll.x += x;
-    obj->rare_attr->scroll.y += y;
+    obj->spec_attr->scroll.x += x;
+    obj->spec_attr->scroll.y += y;
 
     _lv_obj_move_children_by(obj, x, y);
     lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
@@ -177,8 +167,8 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
  */
 lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
 {
-    if(obj->rare_attr == NULL) return 0;
-    return -obj->rare_attr->scroll.y;
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
 }
 
 /**
@@ -226,8 +216,8 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
  */
 lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 {
-    if(obj->rare_attr == NULL) return 0;
-    return -obj->rare_attr->scroll.x;
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.x;
 }
 
 /**
@@ -281,6 +271,52 @@ void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
     end->y = a ? -a->end : lv_obj_get_scroll_top(obj);
 }
 
+lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->scroll_dir;
+    else return LV_DIR_ALL;
+}
+
+void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
+{
+    lv_obj_allocate_rare_attr(obj);
+
+    if(dir != obj->spec_attr->scroll_dir) {
+        obj->spec_attr->scroll_dir = dir;
+        lv_obj_invalidate(obj);
+    }
+}
+
+lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->scroll_mode;
+    else return LV_SCROLL_MODE_AUTO;
+}
+
+lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->snap_align_x;
+    else return LV_SCROLL_SNAP_ALIGN_NONE;
+}
+void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
+{
+    lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->snap_align_x = align;
+}
+
+lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->snap_align_y;
+    else return LV_SCROLL_SNAP_ALIGN_NONE;
+}
+
+void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
+{
+    lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->snap_align_y = align;
+}
+
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index 39ce98686..b357b4aa9 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -55,12 +55,6 @@ typedef uint8_t lv_scroll_snap_align_t;
  */
 void lv_obj_set_scroll_mode(struct _lv_obj_t * obj, lv_scroll_mode_t mode);
 
-/**
- * Get how the scrollbars should behave.
- * @param obj pointer to an object
- * @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
-lv_scroll_mode_t lv_obj_get_scroll_mode(struct _lv_obj_t * obj);
 
 /**
  * Moves all children with horizontally or vertically.
@@ -148,6 +142,16 @@ lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
  */
 void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end);
 
+
+lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj);
+void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir);
+lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj);
+lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj);
+void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
+lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj);
+void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
+
+
 /**********************
  *      MACROS
  **********************/
diff --git a/src/lv_misc/lv_area.h b/src/lv_misc/lv_area.h
index c0602f644..86926d206 100644
--- a/src/lv_misc/lv_area.h
+++ b/src/lv_misc/lv_area.h
@@ -78,6 +78,19 @@ enum {
 };
 typedef uint8_t lv_align_t;
 
+enum {
+    LV_DIR_NONE     = 0x00,
+    LV_DIR_LEFT     = (1 << 0),
+    LV_DIR_RIGHT    = (1 << 1),
+    LV_DIR_TOP      = (1 << 2),
+    LV_DIR_BOTTOM   = (1 << 3),
+    LV_DIR_HOR      = LV_DIR_LEFT | LV_DIR_RIGHT,
+    LV_DIR_VER      = LV_DIR_TOP | LV_DIR_BOTTOM,
+    LV_DIR_ALL      = LV_DIR_HOR | LV_DIR_VER,
+};
+
+typedef uint8_t lv_dir_t;
+
 
 /**********************
  * GLOBAL PROTOTYPES
diff --git a/src/lv_misc/lv_mem.c b/src/lv_misc/lv_mem.c
index 761440723..47d7bace3 100644
--- a/src/lv_misc/lv_mem.c
+++ b/src/lv_misc/lv_mem.c
@@ -161,6 +161,11 @@ void * lv_mem_alloc(size_t size)
         return &zero_mem;
     }
 
+//    last_ent = NULL;
+    static uint32_t c = 0;
+    c++;
+//    if(c%10 == 0) printf("alloc:%d\n", c);
+
 #ifdef LV_ARCH_64
     /*Round the size up to 8*/
     size = (size + 7) & (~0x7);
@@ -171,27 +176,10 @@ void * lv_mem_alloc(size_t size)
     void * alloc = NULL;
 
 #if LV_MEM_CUSTOM == 0
-    static uint32_t defr = 0;
-    defr++;
-    if(defr > LV_MEM_FULL_DEFRAG_CNT) {
-        defr = 0;
-        lv_mem_defrag();
-    }
     alloc = alloc_core(size);
     if(alloc == NULL) {
-        LV_LOG_WARN("Perform defrag");
-        lv_mem_monitor_t mon;
-
-        lv_mem_monitor(&mon);
-        printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
-               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
-               (int)mon.free_biggest_size);
+        LV_LOG_TRACE("No more memory, try to defrag");
         lv_mem_defrag();
-
-        lv_mem_monitor(&mon);
-        printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
-               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
-               (int)mon.free_biggest_size);
         alloc = alloc_core(size);
     }
 
@@ -216,7 +204,12 @@ void * lv_mem_alloc(size_t size)
 #endif
 
     if(alloc == NULL) {
-        LV_LOG_WARN("Couldn't allocate memory");
+        LV_LOG_WARN("Couldn't allocate memory (%d bytes)", size);
+        lv_mem_monitor_t mon;
+        lv_mem_monitor(&mon);
+        LV_LOG_WARN("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
+               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
+               (int)mon.free_biggest_size);
     }
     else {
 #if LV_MEM_CUSTOM == 0
@@ -241,19 +234,23 @@ void lv_mem_free(const void * data)
     if(data == &zero_mem) return;
     if(data == NULL) return;
 
-#if LV_MEM_ADD_JUNK
-    _lv_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));
+#  if LV_MEM_ADD_JUNK
+    _lv_memset((void *)data, 0xbb, _lv_mem_get_size(data));
+#  endif
 #endif
 
-/*Use custom, user defined free function*/
 #if LV_MEM_CUSTOM == 0
     e->header.s.used = 0;
+
+    static uint32_t defr = 0;
+    defr++;
+    if(defr > LV_MEM_FULL_DEFRAG_CNT) {
+        defr = 0;
+        lv_mem_defrag();
+    }
 #else
 #if LV_ENABLE_GC == 0
     /*e points to the header*/
@@ -387,7 +384,7 @@ lv_res_t lv_mem_test(void)
     lv_mem_ent_t * e;
     e = ent_get_next(NULL);
     while(e) {
-        if(e->header.s.d_size > LV_MEM_SIZE) {
+        if( e->header.s.d_size > LV_MEM_SIZE) {
             return LV_RES_INV;
         }
         uint8_t * e8 = (uint8_t *) e;
diff --git a/src/lv_misc/lv_task.c b/src/lv_misc/lv_task.c
index c9b9837ae..954eba29f 100644
--- a/src/lv_misc/lv_task.c
+++ b/src/lv_misc/lv_task.c
@@ -407,6 +407,7 @@ static bool lv_task_exec(lv_task_t * task)
         task_deleted   = false;
         task_created   = false;
         if(task->task_cb) task->task_cb(task);
+        LV_ASSERT_MEM_INTEGRITY();
 
         /*Delete if it was a one shot lv_task*/
         if(task_deleted == false) { /*The task might be deleted by itself as well*/

From a2cc8c3127c3f7f93f6ebdd00c01e65b10b60231 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Sat, 31 Oct 2020 14:22:35 +0100
Subject: [PATCH 69/84] minor fix

---
 src/lv_core/lv_obj.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index ae1259995..5956bf4a7 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -741,7 +741,9 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
             }
         }
         if(cmp_res == _LV_STYLE_STATE_CMP_VISUAL_DIFF) {
+#if LV_STYLE_CACHE_LEVEL > 0
             _lv_obj_invalidate_style_cache(obj, part, LV_STYLE_PROP_ALL);
+#endif
         }
 
     }

From 66dc6250b544f4d9b2009be20e2205831d88880a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 2 Nov 2020 15:52:26 +0100
Subject: [PATCH 70/84] flex, scroll: support RTL base dir

---
 src/lv_core/lv_flex.c       | 116 +++++++++++++++++++++++++++++-------
 src/lv_core/lv_flex.h       |  41 ++++++++++++-
 src/lv_core/lv_grid.c       |   4 +-
 src/lv_core/lv_obj.c        |   4 +-
 src/lv_core/lv_obj_pos.c    |   8 +--
 src/lv_core/lv_obj_scroll.c |  82 +++++++++++++++++++------
 src/lv_core/lv_obj_scroll.h |   4 ++
 src/lv_widgets/lv_line.c    |   4 +-
 src/lv_widgets/lv_table.c   |   8 +--
 9 files changed, 215 insertions(+), 56 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index bf803179f..a262d4db9 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -36,20 +36,45 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place)
+void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
 {
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_rare_attr(obj);
 
-    if(obj->spec_attr->flex_cont.dir == flex_dir && obj->spec_attr->flex_cont.place == flex_place) return;
+    if(obj->spec_attr->flex_cont.dir == flex_dir) return;
 
     obj->spec_attr->flex_cont.dir = flex_dir & 0x3;
     obj->spec_attr->flex_cont.wrap = flex_dir & LV_FLEX_WRAP ? 1 : 0;
     obj->spec_attr->flex_cont.rev = flex_dir & LV_FLEX_REVERSE ? 1 : 0;
-    obj->spec_attr->flex_cont.place = flex_place;
-
     _lv_flex_refresh(obj);
 }
 
+/**
+ * Set how to place the tracks below/next to each other.
+ * For ROW direction it means how to place the rows vertically.
+ * For COLUMN direction it means how to place the column horizontally.
+ * @param obj point to a flex container
+ * @param place the placement type. Can be any element of `lv_flex_place_t`.
+ * @note if the base direction is RTL and the direction is ROW, LV_FLEX_START means the right side
+ */
+void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place)
+{
+    lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr->flex_cont.place == place) return;
+
+    obj->spec_attr->flex_cont.place = place;
+
+    _lv_flex_refresh(obj);
+
+}
+
+/**
+ * Set a gap in the main direction.
+ * For ROW direction it means adding gap horizontally between the items.
+ * For COLUMN direction it means adding gap vertically between the items.
+ * @param obj pointer to an object (flex container)
+ * @param gap the gap in pixels
+ * @note By default the objects are packed tightly after each other
+ */
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
 {
     if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
@@ -61,7 +86,32 @@ void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
     _lv_flex_refresh(obj);
 }
 
-void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
+/**
+ * Make an object flex item, i.e. allow setting it's coordinate according to the parent's flex settings.
+ * @param obj pointer to an object
+ */
+void lv_obj_set_flex_item(lv_obj_t * obj, bool en)
+{
+    if(en) {
+        lv_coord_t f  = _LV_COORD_FELX(LV_FLEX_START);
+        lv_obj_set_pos(obj, f, f);
+    } else {
+        lv_obj_set_pos(obj, lv_obj_get_x(obj), lv_obj_get_y(obj));
+    }
+}
+
+/**
+ * Set how the place the item in it's track in the cross direction.
+ * It has a visible effect only if the objects in the same track has different size in the cross direction.
+ * For ROW direction it means how to place the objects vertically in their row.
+ * For COLUMN direction it means how to place the objects horizontally in their column.
+ * @param obj pointer to a flex item
+ * @param place:
+ *   - `LV_FLEX_START` top/left (in case of RTL base direction right)
+ *   - `LV_FLEX_CENTER` center
+ *   - `LV_FLEX_END` bottom/right (in case of RTL base direction left)
+ */
+void lv_obj_set_flex_item_place(lv_obj_t * obj, lv_flex_place_t place)
 {
     lv_coord_t f  = _LV_COORD_FELX(place);
     lv_obj_set_pos(obj, f, f);
@@ -103,11 +153,12 @@ void _lv_flex_refresh(lv_obj_t * cont)
 
     if(dir == LV_FLEX_DIR_NONE) return;
 
+    bool rtl = lv_obj_get_base_dir(cont) == LV_BIDI_DIR_RTL ? true : false;
     bool row = dir == LV_FLEX_DIR_ROW ? true : false;
     /*Count the grow units and free space*/
     lv_coord_t max_main_size = (row ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
-    lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
-    lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
+    lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_y(cont);
+    lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_x(cont);
 
     lv_coord_t place = lv_obj_get_flex_place(cont);
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
@@ -119,6 +170,11 @@ void _lv_flex_refresh(lv_obj_t * cont)
         place = LV_FLEX_START;
     }
 
+    if(rtl && !row) {
+        if(place == LV_FLEX_START) place = LV_FLEX_END;
+        else if(place == LV_FLEX_END) place = LV_FLEX_START;
+    }
+
     lv_coord_t all_track_size = 0;
     lv_coord_t gap = 0;
     uint32_t row_cnt = 0;
@@ -144,14 +200,26 @@ void _lv_flex_refresh(lv_obj_t * cont)
     }
 
     track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
+
+    if(rtl && !row) {
+         *cross_pos += all_track_size;
+    }
+
     while(track_first_item) {
         /*Search the first item of the next row */
         next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
 
+        if(rtl && !row) {
+            *cross_pos -= track_size;
+        }
         children_repos(cont, track_first_item, next_track_first_item, abs_x, abs_y, track_size, grow_unit);
-
         track_first_item = next_track_first_item;
-        *cross_pos += track_size + gap;
+
+        if(rtl && !row) {
+            *cross_pos -=  gap;
+        } else {
+            *cross_pos += track_size + gap;
+        }
     }
     LV_ASSERT_MEM_INTEGRITY();
 
@@ -236,6 +304,10 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
     lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
     void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
 
+    bool rtl = lv_obj_get_base_dir(cont) == LV_BIDI_DIR_RTL ? true : false;
+
+    if(row && rtl) abs_x += lv_obj_get_width_fit(cont);
+
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t main_pos = 0;
     /*Reposition the children*/
@@ -274,20 +346,15 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             break;
         }
 
-        lv_coord_t diff_x;
-        lv_coord_t diff_y;
-        if(row) {
-            cross_pos += lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
-            main_pos += lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
-            diff_x = abs_x + main_pos - item->coords.x1;
-            diff_y = abs_y + cross_pos - item->coords.y1;
-        } else {
-            main_pos += lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
-            cross_pos += lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
-            diff_x = abs_x + cross_pos - item->coords.x1;
-            diff_y = abs_y + main_pos - item->coords.y1;
+        if(row && rtl) {
+            main_pos -= obj_get_main_size(item) + gap;
         }
 
+        lv_coord_t diff_x = abs_x - item->coords.x1 + lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
+        lv_coord_t diff_y = abs_y - item->coords.y1 + lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
+        diff_x += row ? main_pos : cross_pos;
+        diff_y += row ? cross_pos : main_pos;
+
         if(diff_x || diff_y) {
             item->coords.x1 += diff_x;
             item->coords.x2 += diff_x;
@@ -295,7 +362,10 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             item->coords.y2 += diff_y;
             _lv_obj_move_children_by(item, diff_x, diff_y);
         }
-        main_pos += obj_get_main_size(item) + gap;
+
+        if(!(row && rtl)) {
+            main_pos += obj_get_main_size(item) + gap;
+        }
         item = ll_iter(ll, item);
     }
 }
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 86787d271..e084c8d14 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -58,9 +58,46 @@ typedef struct {
  * GLOBAL PROTOTYPES
  **********************/
 
-void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place);
+void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir);
+
+/**
+ * Set how to place the tracks below/next to each other.
+ * For ROW direction it means how to place the rows vertically.
+ * For COLUMN direction it means how to place the column horizontally.
+ * @param obj point to a flex container
+ * @param place the placement type. Can be any element of `lv_flex_place_t`.
+ * @note if the base direction is RTL and the direction is ROW, LV_FLEX_START means the right side
+ */
+void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place);
+
+/**
+ * Set a gap in the main direction.
+ * For ROW direction it means adding gap horizontally between the items.
+ * For COLUMN direction it means adding gap vertically between the items.
+ * @param obj pointer to an object (flex container)
+ * @param gap the gap in pixels
+ * @note By default the objects are packed tightly after each other
+ */
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap);
-void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
+
+/**
+ * Make an object flex item, i.e. allow setting it's coordinate according to the parent's flex settings.
+ * @param obj pointer to an object
+ */
+void lv_obj_set_flex_item(lv_obj_t * obj, bool en);
+
+/**
+ * Set how the place the item in it's track in the cross direction.
+ * It has a visible effect only if the objects in the same track has different size in the cross direction.
+ * For ROW direction it means how to place the objects vertically in their row.
+ * For COLUMN direction it means how to place the objects horizontally in their column.
+ * @param obj pointer to a flex item
+ * @param place:
+ *   - `LV_FLEX_START` top/left (in case of RTL base direction right)
+ *   - `LV_FLEX_CENTER` center
+ *   - `LV_FLEX_END` bottom/right (in case of RTL base direction left)
+ */
+void lv_obj_set_flex_item_place(lv_obj_t * obj, lv_flex_place_t place);
 
 lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj);
 lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj);
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 49ceed944..c8a857e63 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -192,8 +192,8 @@ void _lv_grid_full_refresh(lv_obj_t * cont)
      * It will be used as helper during item repositioning to avoid calculating this value for every children*/
     lv_coord_t pad_left = lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN);
     lv_coord_t pad_top = lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN);
-    hint.grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_left(cont);
-    hint.grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_top(cont);
+    hint.grid_abs.x = pad_left + cont->coords.x1 - lv_obj_get_scroll_x(cont);
+    hint.grid_abs.y = pad_top + cont->coords.y1 - lv_obj_get_scroll_y(cont);
 
     lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
     while(item) {
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 5956bf4a7..4fd045144 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1824,8 +1824,8 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             lv_point_t grid_abs;
             lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
             lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
-            grid_abs.x = pad_left + obj->coords.x1 - lv_obj_get_scroll_left(obj);
-            grid_abs.y = pad_top + obj->coords.y1 - lv_obj_get_scroll_top(obj);
+            grid_abs.x = pad_left + obj->coords.x1 - lv_obj_get_scroll_x(obj);
+            grid_abs.y = pad_top + obj->coords.y1 - lv_obj_get_scroll_y(obj);
 
             uint32_t row;
             uint32_t col;
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index d6392ed5b..b40924666 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -419,7 +419,7 @@ lv_coord_t lv_obj_get_x(const lv_obj_t * obj)
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent) {
         rel_x   = obj->coords.x1 - parent->coords.x1;
-        rel_x += lv_obj_get_scroll_left(parent);
+        rel_x += lv_obj_get_scroll_x(parent);
         rel_x -= lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
     }
     else {
@@ -444,7 +444,7 @@ lv_coord_t lv_obj_get_y(const lv_obj_t * obj)
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent) {
         rel_y = obj->coords.y1 - parent->coords.y1;
-        rel_y += lv_obj_get_scroll_top(parent);
+        rel_y += lv_obj_get_scroll_y(parent);
         rel_y -= lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
     }
     else {
@@ -638,8 +638,8 @@ void _lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_par
         lv_coord_t pad_left = lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
         lv_coord_t pad_top = lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
 
-        x += pad_left + parent->coords.x1 - lv_obj_get_scroll_left(parent);
-        y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
+        x += pad_left + parent->coords.x1 - lv_obj_get_scroll_x(parent);
+        y += pad_top + parent->coords.y1 - lv_obj_get_scroll_y(parent);
     } else {
         /*If no parent then it's screen but screen can't be on a grid*/
         if(LV_COORD_IS_GRID(obj->x_set) || LV_COORD_IS_GRID(obj->x_set)) {
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 6fb485754..ec74e5ea1 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -102,8 +102,8 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
             if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
             lv_anim_set_time(&a, t);
-            lv_coord_t sl = lv_obj_get_scroll_left(obj);
-            lv_anim_set_values(&a, -sl, -sl + x);
+            lv_coord_t sx = lv_obj_get_scroll_x(obj);
+            lv_anim_set_values(&a, -sx, -sx + x);
             lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t) scroll_anim_x_cb);
             lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
@@ -114,8 +114,8 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
             if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
             lv_anim_set_time(&a, t);
-            lv_coord_t st = lv_obj_get_scroll_top(obj);
-            lv_anim_set_values(&a, -st, -st + y);
+            lv_coord_t sy = lv_obj_get_scroll_y(obj);
+            lv_anim_set_values(&a, -sy, -sy + y);
             lv_anim_set_exec_cb(&a,  (lv_anim_exec_xcb_t) scroll_anim_y_cb);
             lv_anim_set_path(&a, &path);
             lv_anim_start(&a);
@@ -144,7 +144,7 @@ void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
  */
 void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, -x + lv_obj_get_scroll_left(obj), 0, anim_en);
+    lv_obj_scroll_by(obj, -x + lv_obj_get_scroll_x(obj), 0, anim_en);
 }
 
 /**
@@ -154,9 +154,20 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
  */
 void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
 {
-    lv_obj_scroll_by(obj, 0,  -y + lv_obj_get_scroll_top(obj), anim_en);
+    lv_obj_scroll_by(obj, 0,  -y + lv_obj_get_scroll_y(obj), anim_en);
 }
 
+lv_coord_t lv_obj_get_scroll_x(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.x;
+}
+
+lv_coord_t lv_obj_get_scroll_y(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
+}
 
 /**
  * Return the height of the area above the parent.
@@ -203,7 +214,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
 
     lv_coord_t self_h = _lv_obj_get_self_height(obj);
     self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
-    self_h -= lv_obj_get_scroll_top(obj);
+    self_h -= lv_obj_get_scroll_y(obj);
     return LV_MATH_MAX(child_res, self_h);
 }
 
@@ -216,8 +227,38 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
  */
 lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 {
-    if(obj->spec_attr == NULL) return 0;
-    return -obj->spec_attr->scroll.x;
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    /* Normally can't scroll the object out on the left.
+     * So simply use the current scroll position as "left size"*/
+    if(lv_obj_get_base_dir(obj) != LV_BIDI_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return -obj->spec_attr->scroll.x;
+    }
+    /*With RTL base direction scrolling the left is normal so find the left most coordinate*/
+    else {
+        lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+         lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+
+        lv_coord_t child_res = 0;
+        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+        if(child) {
+            lv_coord_t x1 = LV_COORD_MAX;
+            while(child) {
+                x1 = LV_MATH_MIN(x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
+                child = lv_obj_get_child(obj, child);
+            }
+            child_res = x1;
+
+            child_res = (obj->coords.x1 + pad_left) - child_res;
+        }
+
+        lv_coord_t self_w = _lv_obj_get_self_width(obj);
+        self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+        self_w -= lv_obj_get_scroll_x(obj);
+
+        return LV_MATH_MAX(child_res, self_w);
+    }
 }
 
 /**
@@ -231,6 +272,8 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
+    /* Unlike `scroll_left`, `scroll_right` should be calculated regardless to the base direction.
+     * It's because `scroll_x` is always measured from the left side of the object hence there is no information about right side. */
     lv_coord_t child_res = LV_COORD_MIN;
     lv_obj_t * child = lv_obj_get_child(obj, NULL);
     if(child) {
@@ -248,10 +291,15 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
 
     child_res -= (obj->coords.x2 - pad_right);
 
-    lv_coord_t self_w = _lv_obj_get_self_width(obj);
-    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-    self_w -= lv_obj_get_scroll_left(obj);
-
+    lv_coord_t self_w;
+    /*With RTL base dir self_width is handled in `scroll_right`*/
+    if(lv_obj_get_base_dir(obj) != LV_BIDI_DIR_RTL) {
+        self_w = _lv_obj_get_self_width(obj);
+        self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+        self_w -= lv_obj_get_scroll_x(obj);
+    } else {
+        self_w = LV_COORD_MIN;
+    }
     return LV_MATH_MAX(child_res, self_w);
 }
 
@@ -265,10 +313,10 @@ void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
 {
     lv_anim_t * a;
     a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_x_cb);
-    end->x = a ? -a->end : lv_obj_get_scroll_left(obj);
+    end->x = a ? -a->end : lv_obj_get_scroll_x(obj);
 
     a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_y_cb);
-    end->y = a ? -a->end : lv_obj_get_scroll_top(obj);
+    end->y = a ? -a->end : lv_obj_get_scroll_y(obj);
 }
 
 lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj)
@@ -323,10 +371,10 @@ void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t alig
 
 static void scroll_anim_x_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
-    _lv_obj_scroll_by_raw(obj, v + lv_obj_get_scroll_left(obj), 0);
+    _lv_obj_scroll_by_raw(obj, v + lv_obj_get_scroll_x(obj), 0);
 }
 
 static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v)
 {
-    _lv_obj_scroll_by_raw(obj, 0, v + lv_obj_get_scroll_top(obj));
+    _lv_obj_scroll_by_raw(obj, 0, v + lv_obj_get_scroll_y(obj));
 }
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index b357b4aa9..f69f3e3f9 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -97,7 +97,11 @@ void lv_obj_scroll_to_x(struct _lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t a
 void lv_obj_scroll_to_y(struct _lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
 
 
+lv_coord_t lv_obj_get_scroll_x(const struct _lv_obj_t * obj);
+
+lv_coord_t lv_obj_get_scroll_y(const struct _lv_obj_t * obj);
 /**
+ *
  * Return the height of the area above the parent.
  * That is the number of pixels the object can be scrolled down.
  * Normally positive but can be negative when scrolled inside.
diff --git a/src/lv_widgets/lv_line.c b/src/lv_widgets/lv_line.c
index 1d7ae5b92..642edfc6d 100644
--- a/src/lv_widgets/lv_line.c
+++ b/src/lv_widgets/lv_line.c
@@ -185,8 +185,8 @@ static lv_design_res_t lv_line_design(lv_obj_t * line, const lv_area_t * clip_ar
 
         lv_area_t area;
         lv_obj_get_coords(line, &area);
-        lv_coord_t x_ofs = area.x1 - lv_obj_get_scroll_top(line);
-        lv_coord_t y_ofs = area.y1 - lv_obj_get_scroll_left(line);
+        lv_coord_t x_ofs = area.x1 - lv_obj_get_scroll_x(line);
+        lv_coord_t y_ofs = area.y1 - lv_obj_get_scroll_y(line);
         lv_point_t p1;
         lv_point_t p2;
         lv_coord_t h = lv_obj_get_height(line);
diff --git a/src/lv_widgets/lv_table.c b/src/lv_widgets/lv_table.c
index 56f6f4fa3..77a0c67d3 100644
--- a/src/lv_widgets/lv_table.c
+++ b/src/lv_widgets/lv_table.c
@@ -817,8 +817,8 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
         uint16_t row;
         uint16_t cell = 0;
 
-        cell_area.y2 = table->coords.y1 + bg_top - 1 - lv_obj_get_scroll_top(table);
-        lv_coord_t scroll_left = lv_obj_get_scroll_left(table);
+        cell_area.y2 = table->coords.y1 + bg_top - 1 - lv_obj_get_scroll_y(table);
+        lv_coord_t scroll_x = lv_obj_get_scroll_x(table);
         bool rtl = lv_obj_get_base_dir(table) == LV_BIDI_DIR_RTL ? true : false;
 
         for(row = 0; row < ext->row_cnt; row++) {
@@ -829,8 +829,8 @@ static lv_design_res_t lv_table_design(lv_obj_t * table, const lv_area_t * clip_
 
             if(cell_area.y1 > clip_area->y2) return LV_DESIGN_RES_OK;
 
-            if(rtl) cell_area.x1 = table->coords.x2 - bg_right - 1 - scroll_left;
-            else cell_area.x2 = table->coords.x1 + bg_left - 1 - scroll_left;
+            if(rtl) cell_area.x1 = table->coords.x2 - bg_right - 1 - scroll_x;
+            else cell_area.x2 = table->coords.x1 + bg_left - 1 - scroll_x;
 
             for(col = 0; col < ext->col_cnt; col++) {
 

From d98b933b05ed5617db6bb3e2d470ccf99a1204f0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 3 Nov 2020 11:26:53 +0100
Subject: [PATCH 71/84] refactor(flex): use dedicated defines for flex_dir
 instead of OR-ing

---
 src/lv_core/lv_flex.c |  4 ++--
 src/lv_core/lv_flex.h | 14 ++++++++++----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index a262d4db9..c95b2387b 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -43,8 +43,8 @@ void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
     if(obj->spec_attr->flex_cont.dir == flex_dir) return;
 
     obj->spec_attr->flex_cont.dir = flex_dir & 0x3;
-    obj->spec_attr->flex_cont.wrap = flex_dir & LV_FLEX_WRAP ? 1 : 0;
-    obj->spec_attr->flex_cont.rev = flex_dir & LV_FLEX_REVERSE ? 1 : 0;
+    obj->spec_attr->flex_cont.wrap = flex_dir & _LV_FLEX_WRAP ? 1 : 0;
+    obj->spec_attr->flex_cont.rev = flex_dir & _LV_FLEX_REVERSE ? 1 : 0;
     _lv_flex_refresh(obj);
 }
 
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index e084c8d14..970d2e41f 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -24,8 +24,8 @@ extern "C" {
 
 #define _LV_FLEX_GET_GROW(v) (LV_COORD_IS_FLEX(v) ? LV_COORD_GET_FLEX(v) : 0)
 
-#define LV_FLEX_WRAP       (1 << 2)
-#define LV_FLEX_REVERSE    (1 << 3)
+#define _LV_FLEX_WRAP       (1 << 2)
+#define _LV_FLEX_REVERSE    (1 << 3)
 
 /**********************
  *      TYPEDEFS
@@ -42,8 +42,14 @@ typedef enum {
 
 typedef enum {
     LV_FLEX_DIR_NONE,
-    LV_FLEX_DIR_ROW,
-    LV_FLEX_DIR_COLUMN,
+    LV_FLEX_DIR_ROW = 0x01,
+    LV_FLEX_DIR_COLUMN = 0x02,
+    LV_FLEX_DIR_ROW_WRAP = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP,
+    LV_FLEX_DIR_ROW_REVERSE = LV_FLEX_DIR_ROW | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_ROW_WRAP_REVERSE = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_COLUMN_WRAP = LV_FLEX_DIR_COLUMN | _LV_FLEX_WRAP,
+    LV_FLEX_DIR_COLUMN_REVERSE = LV_FLEX_DIR_COLUMN | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_COLUMN_WRAP_REVERSE = LV_FLEX_DIR_COLUMN | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
 }lv_flex_dir_t;
 
 typedef struct {

From 1fa0c5527fe04ddf16b95bd4954db8a8bb99dc30 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 3 Nov 2020 11:48:27 +0100
Subject: [PATCH 72/84] perf(scroll): simplify lv_obj_get_scroll_right with RTL
 base direction

---
 src/lv_core/lv_obj_scroll.c | 62 ++++++++++++++++++-------------------
 src/lv_core/lv_obj_scroll.h |  4 +--
 2 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index ec74e5ea1..1fe322116 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -176,7 +176,7 @@ lv_coord_t lv_obj_get_scroll_y(const lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
 {
     if(obj->spec_attr == NULL) return 0;
     return -obj->spec_attr->scroll.y;
@@ -225,7 +225,7 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
+lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -235,30 +235,29 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
         if(obj->spec_attr == NULL) return 0;
         return -obj->spec_attr->scroll.x;
     }
+
     /*With RTL base direction scrolling the left is normal so find the left most coordinate*/
-    else {
-        lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-         lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
 
-        lv_coord_t child_res = 0;
-        lv_obj_t * child = lv_obj_get_child(obj, NULL);
-        if(child) {
-            lv_coord_t x1 = LV_COORD_MAX;
-            while(child) {
-                x1 = LV_MATH_MIN(x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
-                child = lv_obj_get_child(obj, child);
-            }
-            child_res = x1;
-
-            child_res = (obj->coords.x1 + pad_left) - child_res;
+    lv_coord_t child_res = 0;
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child) {
+        lv_coord_t x1 = LV_COORD_MAX;
+        while(child) {
+            x1 = LV_MATH_MIN(x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
         }
+        child_res = x1;
 
-        lv_coord_t self_w = _lv_obj_get_self_width(obj);
-        self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-        self_w -= lv_obj_get_scroll_x(obj);
-
-        return LV_MATH_MAX(child_res, self_w);
+        child_res = (obj->coords.x1 + pad_left) - child_res;
     }
+
+    lv_coord_t self_w = _lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+    self_w -= lv_obj_get_scroll_x(obj);
+
+    return LV_MATH_MAX(child_res, self_w);
 }
 
 /**
@@ -272,8 +271,14 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    /* Unlike `scroll_left`, `scroll_right` should be calculated regardless to the base direction.
-     * It's because `scroll_x` is always measured from the left side of the object hence there is no information about right side. */
+    /* With RTL base dir can't scroll to the object out on the right.
+     * So simply use the current scroll position as "right size"*/
+    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return obj->spec_attr->scroll.x;
+    }
+
+    /*With other base direction (LTR) scrolling to the right is normal so find the right most coordinate*/
     lv_coord_t child_res = LV_COORD_MIN;
     lv_obj_t * child = lv_obj_get_child(obj, NULL);
     if(child) {
@@ -292,14 +297,9 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
     child_res -= (obj->coords.x2 - pad_right);
 
     lv_coord_t self_w;
-    /*With RTL base dir self_width is handled in `scroll_right`*/
-    if(lv_obj_get_base_dir(obj) != LV_BIDI_DIR_RTL) {
-        self_w = _lv_obj_get_self_width(obj);
-        self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-        self_w -= lv_obj_get_scroll_x(obj);
-    } else {
-        self_w = LV_COORD_MIN;
-    }
+    self_w = _lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+    self_w -= lv_obj_get_scroll_x(obj);
     return LV_MATH_MAX(child_res, self_w);
 }
 
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index f69f3e3f9..f48dd5096 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -108,7 +108,7 @@ lv_coord_t lv_obj_get_scroll_y(const struct _lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_top(const struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_top(struct _lv_obj_t * obj);
 
 /**
  * Return the height of the area below the parent.
@@ -127,7 +127,7 @@ lv_coord_t lv_obj_get_scroll_bottom(struct _lv_obj_t * obj);
  * @param obj
  * @return
  */
-lv_coord_t lv_obj_get_scroll_left(const struct _lv_obj_t * obj);
+lv_coord_t lv_obj_get_scroll_left(struct _lv_obj_t * obj);
 
 /**
  * Return the width of the area below the object.

From d12af050faae1e68388fb97dc62de5881faf6584 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 3 Nov 2020 13:19:54 +0100
Subject: [PATCH 73/84] style: comment update in lv_flex.c and lv_obj_scroll

---
 src/lv_core/lv_flex.c         | 143 ++++++-----
 src/lv_core/lv_flex.h         | 103 +++++---
 src/lv_core/lv_indev_scroll.c |   8 +-
 src/lv_core/lv_obj.h          |   4 +-
 src/lv_core/lv_obj_scroll.c   | 430 +++++++++++++++-------------------
 src/lv_core/lv_obj_scroll.h   | 127 +++++-----
 6 files changed, 409 insertions(+), 406 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index c95b2387b..fb9ad67f5 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -24,6 +24,10 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
 static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit);
 static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
 
+static lv_flex_dir_t get_dir(const lv_obj_t * obj);
+static bool get_rev(const lv_obj_t * obj);
+static bool get_wrap(const lv_obj_t * obj);
+
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -36,6 +40,10 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
  *   GLOBAL FUNCTIONS
  **********************/
 
+/*=====================
+ * Setter functions
+ *====================*/
+
 void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
 {
     lv_obj_allocate_rare_attr(obj);
@@ -48,14 +56,6 @@ void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
     _lv_flex_refresh(obj);
 }
 
-/**
- * Set how to place the tracks below/next to each other.
- * For ROW direction it means how to place the rows vertically.
- * For COLUMN direction it means how to place the column horizontally.
- * @param obj point to a flex container
- * @param place the placement type. Can be any element of `lv_flex_place_t`.
- * @note if the base direction is RTL and the direction is ROW, LV_FLEX_START means the right side
- */
 void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place)
 {
     lv_obj_allocate_rare_attr(obj);
@@ -64,17 +64,8 @@ void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place)
     obj->spec_attr->flex_cont.place = place;
 
     _lv_flex_refresh(obj);
-
 }
 
-/**
- * Set a gap in the main direction.
- * For ROW direction it means adding gap horizontally between the items.
- * For COLUMN direction it means adding gap vertically between the items.
- * @param obj pointer to an object (flex container)
- * @param gap the gap in pixels
- * @note By default the objects are packed tightly after each other
- */
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
 {
     if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
@@ -86,59 +77,40 @@ void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
     _lv_flex_refresh(obj);
 }
 
-/**
- * Make an object flex item, i.e. allow setting it's coordinate according to the parent's flex settings.
- * @param obj pointer to an object
- */
 void lv_obj_set_flex_item(lv_obj_t * obj, bool en)
 {
     if(en) {
-        lv_coord_t f  = _LV_COORD_FELX(LV_FLEX_START);
+        lv_coord_t f  = _LV_COORD_FELX(LV_FLEX_PLACE_START);
         lv_obj_set_pos(obj, f, f);
     } else {
         lv_obj_set_pos(obj, lv_obj_get_x(obj), lv_obj_get_y(obj));
     }
 }
 
-/**
- * Set how the place the item in it's track in the cross direction.
- * It has a visible effect only if the objects in the same track has different size in the cross direction.
- * For ROW direction it means how to place the objects vertically in their row.
- * For COLUMN direction it means how to place the objects horizontally in their column.
- * @param obj pointer to a flex item
- * @param place:
- *   - `LV_FLEX_START` top/left (in case of RTL base direction right)
- *   - `LV_FLEX_CENTER` center
- *   - `LV_FLEX_END` bottom/right (in case of RTL base direction left)
- */
 void lv_obj_set_flex_item_place(lv_obj_t * obj, lv_flex_place_t place)
 {
-    lv_coord_t f  = _LV_COORD_FELX(place);
-    lv_obj_set_pos(obj, f, f);
+    if(place == LV_FLEX_PLACE_NONE) {
+        lv_obj_set_pos(obj, lv_obj_get_x(obj), lv_obj_get_x(obj));
+    } else {
+        lv_coord_t f  = _LV_COORD_FELX(place);
+        lv_obj_set_pos(obj, f, f);
+    }
 }
 
+/*=====================
+ * Getter functions
+ *====================*/
+
 lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj)
 {
     if(obj->spec_attr) return obj->spec_attr->flex_cont.dir;
     else return LV_FLEX_DIR_NONE;
 }
 
-lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj)
+lv_flex_place_t lv_obj_get_flex_track_place(const lv_obj_t * obj)
 {
     if(obj->spec_attr) return obj->spec_attr->flex_cont.place;
-    else return LV_FLEX_START;
-}
-
-bool lv_obj_get_flex_wrap(const lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->flex_cont.wrap;
-    else return false;
-}
-
-bool lv_obj_get_flex_reverse(const lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->flex_cont.rev;
-    else return false;
+    else return LV_FLEX_PLACE_START;
 }
 
 lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj)
@@ -147,9 +119,16 @@ lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj)
     else return 0;
 }
 
+lv_flex_place_t lv_obj_get_flex_item_place(lv_obj_t * obj)
+{
+    lv_coord_t x = lv_obj_get_x(obj);
+    if(LV_COORD_IS_FLEX(x)) return LV_COORD_GET_FLEX(x);
+    else return LV_FLEX_PLACE_NONE;
+}
+
 void _lv_flex_refresh(lv_obj_t * cont)
 {
-    lv_flex_dir_t dir = lv_obj_get_flex_dir(cont);
+    lv_flex_dir_t dir = get_dir(cont);
 
     if(dir == LV_FLEX_DIR_NONE) return;
 
@@ -160,19 +139,19 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_y(cont);
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_x(cont);
 
-    lv_coord_t place = lv_obj_get_flex_place(cont);
+    lv_coord_t place = lv_obj_get_flex_track_place(cont);
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
 
     if((row && cont->h_set == LV_SIZE_AUTO) ||
        (!row && cont->w_set == LV_SIZE_AUTO))
     {
-        place = LV_FLEX_START;
+        place = LV_FLEX_PLACE_START;
     }
 
     if(rtl && !row) {
-        if(place == LV_FLEX_START) place = LV_FLEX_END;
-        else if(place == LV_FLEX_END) place = LV_FLEX_START;
+        if(place == LV_FLEX_PLACE_START) place = LV_FLEX_PLACE_END;
+        else if(place == LV_FLEX_PLACE_END) place = LV_FLEX_PLACE_START;
     }
 
     lv_coord_t all_track_size = 0;
@@ -182,9 +161,9 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t track_size;
     lv_obj_t * track_first_item;
     lv_obj_t * next_track_first_item;
-    bool rev = lv_obj_get_flex_reverse(cont);
+    bool rev = get_rev(cont);
 
-    if(place != LV_FLEX_START) {
+    if(place != LV_FLEX_PLACE_START) {
         track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
 
         while(track_first_item) {
@@ -222,7 +201,6 @@ void _lv_flex_refresh(lv_obj_t * cont)
         }
     }
     LV_ASSERT_MEM_INTEGRITY();
-
 }
 
 /**********************
@@ -231,10 +209,10 @@ void _lv_flex_refresh(lv_obj_t * cont)
 
 static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
 {
-    bool wrap = lv_obj_get_flex_wrap(cont);
-    bool rev = lv_obj_get_flex_reverse(cont);
+    bool wrap = get_wrap(cont);
+    bool rev = get_rev(cont);
     lv_coord_t gap = lv_obj_get_flex_gap(cont);
-    bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
+    bool row = get_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
     lv_coord_t(*get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
@@ -292,9 +270,9 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
 
 static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
 {
-    bool rev = lv_obj_get_flex_reverse(cont);
+    bool rev = get_rev(cont);
     lv_coord_t gap = lv_obj_get_flex_gap(cont);
-    bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
+    bool row = get_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
 
     lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
@@ -338,10 +316,10 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         lv_coord_t cross_pos = 0;
         lv_coord_t cross_set = (row ? item->y_set : item->x_set);
         switch(LV_COORD_GET_FLEX(cross_set)) {
-        case LV_FLEX_CENTER:
+        case LV_FLEX_PLACE_CENTER:
             cross_pos = (track_size - obj_get_cross_size(item)) / 2;
             break;
-        case LV_FLEX_END:
+        case LV_FLEX_PLACE_END:
             cross_pos = track_size - obj_get_cross_size(item);
             break;
         }
@@ -370,34 +348,33 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
     }
 }
 
-
 static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap)
 {
     if(track_cnt <= 1) {
         switch(place) {
-            case LV_FLEX_SPACE_BETWEEN:
-            case LV_FLEX_SPACE_AROUND:
-            case LV_FLEX_SPACE_EVENLY:
-                place = LV_FLEX_CENTER;
+            case LV_FLEX_PLACE_SPACE_BETWEEN:
+            case LV_FLEX_PLACE_SPACE_AROUND:
+            case LV_FLEX_PLACE_SPACE_EVENLY:
+                place = LV_FLEX_PLACE_CENTER;
                 break;
         }
     }
 
     switch(place) {
-    case LV_FLEX_CENTER:
+    case LV_FLEX_PLACE_CENTER:
         *start_pos += (max_size - track_size) / 2;
         break;
-    case LV_FLEX_END:
+    case LV_FLEX_PLACE_END:
         *start_pos += max_size - track_size;
         break;
-    case LV_FLEX_SPACE_BETWEEN:
+    case LV_FLEX_PLACE_SPACE_BETWEEN:
        *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt - 1);
        break;
-   case LV_FLEX_SPACE_AROUND:
+   case LV_FLEX_PLACE_SPACE_AROUND:
        *gap += (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt);
        *start_pos += *gap / 2;
        break;
-   case LV_FLEX_SPACE_EVENLY:
+   case LV_FLEX_PLACE_SPACE_EVENLY:
        *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt + 1);
        *start_pos += *gap;
        break;
@@ -405,3 +382,21 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
        *gap = 0;
     }
 }
+
+static lv_flex_dir_t get_dir(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.dir;
+    else return false;
+}
+
+static bool get_rev(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.rev;
+    else return false;
+}
+
+static bool get_wrap(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.wrap;
+    else return false;
+}
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 970d2e41f..978c475dd 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -13,7 +13,7 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_grid.h"
+#include "../lv_misc/lv_area.h"
 
 /*********************
  *      DEFINES
@@ -31,24 +31,28 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+/* Can't include lv_obj.h because it includes this header file */
+struct _lv_obj_t;
+
 typedef enum {
-    LV_FLEX_START,
-    LV_FLEX_END,
-    LV_FLEX_CENTER,
-    LV_FLEX_SPACE_EVENLY,
-    LV_FLEX_SPACE_AROUND,
-    LV_FLEX_SPACE_BETWEEN,
+    LV_FLEX_PLACE_NONE,
+    LV_FLEX_PLACE_START,
+    LV_FLEX_PLACE_END,
+    LV_FLEX_PLACE_CENTER,
+    LV_FLEX_PLACE_SPACE_EVENLY,
+    LV_FLEX_PLACE_SPACE_AROUND,
+    LV_FLEX_PLACE_SPACE_BETWEEN,
 }lv_flex_place_t;
 
 typedef enum {
     LV_FLEX_DIR_NONE,
-    LV_FLEX_DIR_ROW = 0x01,
-    LV_FLEX_DIR_COLUMN = 0x02,
-    LV_FLEX_DIR_ROW_WRAP = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP,
-    LV_FLEX_DIR_ROW_REVERSE = LV_FLEX_DIR_ROW | _LV_FLEX_REVERSE,
-    LV_FLEX_DIR_ROW_WRAP_REVERSE = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
-    LV_FLEX_DIR_COLUMN_WRAP = LV_FLEX_DIR_COLUMN | _LV_FLEX_WRAP,
-    LV_FLEX_DIR_COLUMN_REVERSE = LV_FLEX_DIR_COLUMN | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_ROW                 = 0x01,
+    LV_FLEX_DIR_COLUMN              = 0x02,
+    LV_FLEX_DIR_ROW_WRAP            = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP,
+    LV_FLEX_DIR_ROW_REVERSE         = LV_FLEX_DIR_ROW | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_ROW_WRAP_REVERSE    = LV_FLEX_DIR_ROW | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
+    LV_FLEX_DIR_COLUMN_WRAP         = LV_FLEX_DIR_COLUMN | _LV_FLEX_WRAP,
+    LV_FLEX_DIR_COLUMN_REVERSE      = LV_FLEX_DIR_COLUMN | _LV_FLEX_REVERSE,
     LV_FLEX_DIR_COLUMN_WRAP_REVERSE = LV_FLEX_DIR_COLUMN | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
 }lv_flex_dir_t;
 
@@ -64,7 +68,18 @@ typedef struct {
  * GLOBAL PROTOTYPES
  **********************/
 
-void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir);
+/*=====================
+ * Setter functions
+ *====================*/
+
+/**
+ * Makes an object a flex container by setting the direction of the layout.
+ * The children explicitly needs to be made flex items with
+ * `lv_obj_set_flex_item()` or `lv_obj_set_flex_item_place()`
+ * @param obj pointer to an object
+ * @param flex_dir the flex direction, an element of `lv_flex_dir_t`
+ */
+void lv_obj_set_flex_dir(struct _lv_obj_t * obj, lv_flex_dir_t flex_dir);
 
 /**
  * Set how to place the tracks below/next to each other.
@@ -74,7 +89,7 @@ void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir);
  * @param place the placement type. Can be any element of `lv_flex_place_t`.
  * @note if the base direction is RTL and the direction is ROW, LV_FLEX_START means the right side
  */
-void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place);
+void lv_obj_set_flex_track_place(struct _lv_obj_t * obj, lv_flex_place_t place);
 
 /**
  * Set a gap in the main direction.
@@ -84,13 +99,13 @@ void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place);
  * @param gap the gap in pixels
  * @note By default the objects are packed tightly after each other
  */
-void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap);
+void lv_obj_set_flex_gap(struct _lv_obj_t * obj, lv_coord_t gap);
 
 /**
  * Make an object flex item, i.e. allow setting it's coordinate according to the parent's flex settings.
  * @param obj pointer to an object
  */
-void lv_obj_set_flex_item(lv_obj_t * obj, bool en);
+void lv_obj_set_flex_item(struct _lv_obj_t * obj, bool en);
 
 /**
  * Set how the place the item in it's track in the cross direction.
@@ -99,18 +114,50 @@ void lv_obj_set_flex_item(lv_obj_t * obj, bool en);
  * For COLUMN direction it means how to place the objects horizontally in their column.
  * @param obj pointer to a flex item
  * @param place:
- *   - `LV_FLEX_START` top/left (in case of RTL base direction right)
- *   - `LV_FLEX_CENTER` center
- *   - `LV_FLEX_END` bottom/right (in case of RTL base direction left)
+ *   - `LV_FLEX_PLACE_START` top/left (in case of RTL base direction right)
+ *   - `LV_FLEX_PLACE_CENTER` center
+ *   - `LV_FLEX_PLACE_END` bottom/right (in case of RTL base direction left)
  */
-void lv_obj_set_flex_item_place(lv_obj_t * obj, lv_flex_place_t place);
+void lv_obj_set_flex_item_place(struct _lv_obj_t * obj, lv_flex_place_t place);
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/**
+ * Get the flex direction of an object
+ * @param obj pointer to an object
+ * @return the flex direction of `obj`
+ */
+lv_flex_dir_t lv_obj_get_flex_dir(const struct _lv_obj_t * obj);
+
+/**
+ * Get the track placement of a flex container
+ * @param obj pointer to an object
+ * @return the track placement
+ */
+lv_flex_place_t lv_obj_get_flex_track_place(const struct _lv_obj_t * obj);
+/**
+ * Get flex gap
+ * @param obj pointer to an flex container
+ * @return the gap in pixels
+ */
+lv_coord_t lv_obj_get_flex_gap(const struct _lv_obj_t * obj);
+
+/**
+ * Get how the flex item is placed in its track in the cross direction.
+ * For ROW direction it means how the item is placed vertically in its row.
+ * For COLUMN direction it means how the item is placed horizontally in its column.
+ * @param obj pointer to a flex item
+ * @return `LV_FLEX_PLACE_NONE/START/CENTER/END`
+ */
+lv_flex_place_t lv_obj_get_flex_item_place(struct _lv_obj_t * obj);
+/**
+ * Rearrange the flex items of a flex container
+ * @param cont pointer to a flex container object
+ */
+void _lv_flex_refresh(struct _lv_obj_t * cont);
 
-lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj);
-lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj);
-bool lv_obj_get_flex_wrap(const lv_obj_t * obj);
-bool lv_obj_get_flex_reverse(const lv_obj_t * obj);
-lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj);
-void _lv_flex_refresh(lv_obj_t * cont);
 
 /**********************
  *      MACROS
diff --git a/src/lv_core/lv_indev_scroll.c b/src/lv_core/lv_indev_scroll.c
index 4a8518c8e..f95dd0685 100644
--- a/src/lv_core/lv_indev_scroll.c
+++ b/src/lv_core/lv_indev_scroll.c
@@ -116,8 +116,8 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
         proc->types.pointer.scroll_throw_vect.x = 0;
     }
 
-    lv_scroll_snap_align_t align_x = lv_obj_get_snap_align_x(scroll_obj);
-    lv_scroll_snap_align_t align_y = lv_obj_get_snap_align_y(scroll_obj);
+    lv_snap_align_t align_x = lv_obj_get_snap_align_x(scroll_obj);
+    lv_snap_align_t align_y = lv_obj_get_snap_align_y(scroll_obj);
 
     if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
         proc->types.pointer.scroll_throw_vect.x = 0;
@@ -403,7 +403,7 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
 
 static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
 {
-    lv_scroll_snap_align_t align = lv_obj_get_snap_align_x(obj);
+    lv_snap_align_t align = lv_obj_get_snap_align_x(obj);
     if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
 
     lv_coord_t dist = LV_COORD_MAX;
@@ -451,7 +451,7 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
  */
 static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
 {
-    lv_scroll_snap_align_t align = lv_obj_get_snap_align_y(obj);
+    lv_snap_align_t align = lv_obj_get_snap_align_y(obj);
     if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
 
     lv_coord_t dist = LV_COORD_MAX;
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 65fc1e055..5648044a8 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -219,8 +219,8 @@ typedef struct {
 #endif
 
     lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
-    lv_scroll_snap_align_t snap_align_x : 2;
-    lv_scroll_snap_align_t snap_align_y : 2;
+    lv_snap_align_t snap_align_x : 2;
+    lv_snap_align_t snap_align_y : 2;
     lv_scroll_dir_t scroll_dir :4;
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
 }lv_obj_spec_attr_t;
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 1fe322116..9e026f88e 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -38,11 +38,10 @@ static void scroll_anim_y_cb(lv_obj_t * obj, lv_anim_value_t v);
  *   GLOBAL FUNCTIONS
  **********************/
 
-/**
- * Set how the scrollbars should behave.
- * @param obj pointer to an object
- * @param mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
- */
+/*=====================
+ * Setter functions
+ *====================*/
+
 void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@@ -54,13 +53,188 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
     lv_obj_invalidate(obj);
 }
 
-/**
- * Moves all children with horizontally or vertically.
- * It doesn't take into account any limits so any values are possible
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
+void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
+{
+    lv_obj_allocate_rare_attr(obj);
+
+    if(dir != obj->spec_attr->scroll_dir) {
+        obj->spec_attr->scroll_dir = dir;
+        lv_obj_invalidate(obj);
+    }
+}
+
+void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_snap_align_t align)
+{
+    lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->snap_align_x = align;
+}
+
+void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_snap_align_t align)
+{
+    lv_obj_allocate_rare_attr(obj);
+    obj->spec_attr->snap_align_y = align;
+}
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->scroll_mode;
+    else return LV_SCROLL_MODE_AUTO;
+}
+
+lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->scroll_dir;
+    else return LV_DIR_ALL;
+}
+
+lv_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->snap_align_x;
+    else return LV_SCROLL_SNAP_ALIGN_NONE;
+}
+
+lv_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->snap_align_y;
+    else return LV_SCROLL_SNAP_ALIGN_NONE;
+}
+
+lv_coord_t lv_obj_get_scroll_x(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.x;
+}
+
+lv_coord_t lv_obj_get_scroll_y(const lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
+}
+
+lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
+{
+    if(obj->spec_attr == NULL) return 0;
+    return -obj->spec_attr->scroll.y;
+}
+
+lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    lv_coord_t child_res = LV_COORD_MIN;
+
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child) {
+        lv_coord_t y2 = LV_COORD_MIN;
+        while(child) {
+            y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
+        }
+
+        child_res = y2;
+    }
+
+
+    lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
+
+    child_res -= (obj->coords.y2 - pad_bottom);
+
+    lv_coord_t self_h = _lv_obj_get_self_height(obj);
+    self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
+    self_h -= lv_obj_get_scroll_y(obj);
+    return LV_MATH_MAX(child_res, self_h);
+}
+
+lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    /* Normally can't scroll the object out on the left.
+     * So simply use the current scroll position as "left size"*/
+    if(lv_obj_get_base_dir(obj) != LV_BIDI_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return -obj->spec_attr->scroll.x;
+    }
+
+    /*With RTL base direction scrolling the left is normal so find the left most coordinate*/
+    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+
+    lv_coord_t child_res = 0;
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child) {
+        lv_coord_t x1 = LV_COORD_MAX;
+        while(child) {
+            x1 = LV_MATH_MIN(x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
+        }
+        child_res = x1;
+
+        child_res = (obj->coords.x1 + pad_left) - child_res;
+    }
+
+    lv_coord_t self_w = _lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+    self_w -= lv_obj_get_scroll_x(obj);
+
+    return LV_MATH_MAX(child_res, self_w);
+}
+
+lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    /* With RTL base dir can't scroll to the object out on the right.
+     * So simply use the current scroll position as "right size"*/
+    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
+        if(obj->spec_attr == NULL) return 0;
+        return obj->spec_attr->scroll.x;
+    }
+
+    /*With other base direction (LTR) scrolling to the right is normal so find the right most coordinate*/
+    lv_coord_t child_res = LV_COORD_MIN;
+    lv_obj_t * child = lv_obj_get_child(obj, NULL);
+    if(child) {
+        lv_coord_t x2 = LV_COORD_MIN;
+        while(child) {
+            x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
+            child = lv_obj_get_child(obj, child);
+        }
+        child_res = x2;
+
+    }
+
+    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
+
+    child_res -= (obj->coords.x2 - pad_right);
+
+    lv_coord_t self_w;
+    self_w = _lv_obj_get_self_width(obj);
+    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
+    self_w -= lv_obj_get_scroll_x(obj);
+    return LV_MATH_MAX(child_res, self_w);
+}
+
+void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
+{
+    lv_anim_t * a;
+    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_x_cb);
+    end->x = a ? -a->end : lv_obj_get_scroll_x(obj);
+
+    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_y_cb);
+    end->y = a ? -a->end : lv_obj_get_scroll_y(obj);
+}
+
+/*=====================
+ * Other functions
+ *====================*/
+
 void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 {
     if(x == 0 && y == 0) return;
@@ -76,13 +250,7 @@ void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     if(res != LV_RES_OK) return;
     lv_obj_invalidate(obj);
 }
-/**
- * Moves all children with horizontally or vertically.
- * Limits the scroll to the bounding box of the children.
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
- */
+
 void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
 {
     if(x == 0 && y == 0) return;
@@ -125,246 +293,22 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
     }
 }
 
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- * @param y the y coordinate to scroll to
- */
 void lv_obj_scroll_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en)
 {
     lv_obj_scroll_to_x(obj, x, anim_en);
     lv_obj_scroll_to_y(obj, y, anim_en);
 }
 
-/**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- */
 void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 {
     lv_obj_scroll_by(obj, -x + lv_obj_get_scroll_x(obj), 0, anim_en);
 }
 
-/**
- * Scroll the a given y coordinate to the top side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param y the y coordinate to scroll to
- */
 void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
 {
     lv_obj_scroll_by(obj, 0,  -y + lv_obj_get_scroll_y(obj), anim_en);
 }
 
-lv_coord_t lv_obj_get_scroll_x(const lv_obj_t * obj)
-{
-    if(obj->spec_attr == NULL) return 0;
-    return -obj->spec_attr->scroll.x;
-}
-
-lv_coord_t lv_obj_get_scroll_y(const lv_obj_t * obj)
-{
-    if(obj->spec_attr == NULL) return 0;
-    return -obj->spec_attr->scroll.y;
-}
-
-/**
- * Return the height of the area above the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_top(lv_obj_t * obj)
-{
-    if(obj->spec_attr == NULL) return 0;
-    return -obj->spec_attr->scroll.y;
-}
-
-/**
- * Return the height of the area below the parent.
- * That is the number of pixels the object can be scrolled up.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    lv_coord_t child_res = LV_COORD_MIN;
-
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child) {
-        lv_coord_t y2 = LV_COORD_MIN;
-        while(child) {
-            y2 = LV_MATH_MAX(y2, child->coords.y2 + lv_obj_get_style_margin_bottom(child, LV_OBJ_PART_MAIN));
-            child = lv_obj_get_child(obj, child);
-        }
-
-        child_res = y2;
-    }
-
-
-    lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-
-    child_res -= (obj->coords.y2 - pad_bottom);
-
-    lv_coord_t self_h = _lv_obj_get_self_height(obj);
-    self_h = self_h - (lv_obj_get_height(obj) - pad_top - pad_bottom);
-    self_h -= lv_obj_get_scroll_y(obj);
-    return LV_MATH_MAX(child_res, self_h);
-}
-
-/**
- * Return the weight of the area on the left the parent.
- * That is the number of pixels the object can be scrolled down.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    /* Normally can't scroll the object out on the left.
-     * So simply use the current scroll position as "left size"*/
-    if(lv_obj_get_base_dir(obj) != LV_BIDI_DIR_RTL) {
-        if(obj->spec_attr == NULL) return 0;
-        return -obj->spec_attr->scroll.x;
-    }
-
-    /*With RTL base direction scrolling the left is normal so find the left most coordinate*/
-    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
-
-    lv_coord_t child_res = 0;
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child) {
-        lv_coord_t x1 = LV_COORD_MAX;
-        while(child) {
-            x1 = LV_MATH_MIN(x1, child->coords.x1 - lv_obj_get_style_margin_left(child, LV_OBJ_PART_MAIN));
-            child = lv_obj_get_child(obj, child);
-        }
-        child_res = x1;
-
-        child_res = (obj->coords.x1 + pad_left) - child_res;
-    }
-
-    lv_coord_t self_w = _lv_obj_get_self_width(obj);
-    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-    self_w -= lv_obj_get_scroll_x(obj);
-
-    return LV_MATH_MAX(child_res, self_w);
-}
-
-/**
- * Return the width of the area below the object.
- * That is the number of pixels the object can be scrolled left.
- * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
- */
-lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
-{
-    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-
-    /* With RTL base dir can't scroll to the object out on the right.
-     * So simply use the current scroll position as "right size"*/
-    if(lv_obj_get_base_dir(obj) == LV_BIDI_DIR_RTL) {
-        if(obj->spec_attr == NULL) return 0;
-        return obj->spec_attr->scroll.x;
-    }
-
-    /*With other base direction (LTR) scrolling to the right is normal so find the right most coordinate*/
-    lv_coord_t child_res = LV_COORD_MIN;
-    lv_obj_t * child = lv_obj_get_child(obj, NULL);
-    if(child) {
-        lv_coord_t x2 = LV_COORD_MIN;
-        while(child) {
-            x2 = LV_MATH_MAX(x2, child->coords.x2 + lv_obj_get_style_margin_right(child, LV_OBJ_PART_MAIN));
-            child = lv_obj_get_child(obj, child);
-        }
-        child_res = x2;
-
-    }
-
-    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
-
-    child_res -= (obj->coords.x2 - pad_right);
-
-    lv_coord_t self_w;
-    self_w = _lv_obj_get_self_width(obj);
-    self_w = self_w - (lv_obj_get_width(obj) - pad_right - pad_left);
-    self_w -= lv_obj_get_scroll_x(obj);
-    return LV_MATH_MAX(child_res, self_w);
-}
-
-/**
- * Get the X and Y coordinates where the scrolling would end for this object if a scrolling animation is in progress.
- * In no scrolling animation give the current `left` or `top` scroll position.
- * @param obj pointer to an object
- * @param end poinr to point to store the result
- */
-void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end)
-{
-    lv_anim_t * a;
-    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_x_cb);
-    end->x = a ? -a->end : lv_obj_get_scroll_x(obj);
-
-    a = lv_anim_get(obj, (lv_anim_exec_xcb_t)scroll_anim_y_cb);
-    end->y = a ? -a->end : lv_obj_get_scroll_y(obj);
-}
-
-lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->scroll_dir;
-    else return LV_DIR_ALL;
-}
-
-void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
-{
-    lv_obj_allocate_rare_attr(obj);
-
-    if(dir != obj->spec_attr->scroll_dir) {
-        obj->spec_attr->scroll_dir = dir;
-        lv_obj_invalidate(obj);
-    }
-}
-
-lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->scroll_mode;
-    else return LV_SCROLL_MODE_AUTO;
-}
-
-lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->snap_align_x;
-    else return LV_SCROLL_SNAP_ALIGN_NONE;
-}
-void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
-{
-    lv_obj_allocate_rare_attr(obj);
-    obj->spec_attr->snap_align_x = align;
-}
-
-lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj)
-{
-    if(obj->spec_attr) return obj->spec_attr->snap_align_y;
-    else return LV_SCROLL_SNAP_ALIGN_NONE;
-}
-
-void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
-{
-    lv_obj_allocate_rare_attr(obj);
-    obj->spec_attr->snap_align_y = align;
-}
-
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index f48dd5096..f4b561eaf 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -24,6 +24,7 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+/* Can't include lv_obj.h because it includes this header file */
 struct _lv_obj_t;
 
 /** Scrollbar modes: shows when should the scrollbars be visible*/
@@ -42,7 +43,7 @@ enum {
     LV_SCROLL_SNAP_ALIGN_END,
     LV_SCROLL_SNAP_ALIGN_CENTER
 };
-typedef uint8_t lv_scroll_snap_align_t;
+typedef uint8_t lv_snap_align_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -55,107 +56,123 @@ typedef uint8_t lv_scroll_snap_align_t;
  */
 void lv_obj_set_scroll_mode(struct _lv_obj_t * obj, lv_scroll_mode_t mode);
 
+/**
+ * Set the object in which directions can be scrolled
+ * @param obj pointer to an object
+ * @param dir the allow scroll directions. An element or OR-ed values of `lv_dir_t`
+ */
+void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir);
 
 /**
- * Moves all children with horizontally or vertically.
- * It doesn't take into account any limits so any values are possible
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
+ * Set where to snap the children when scrolling ends horizontally
+ * @param obj pointer to an object
+ * @param align the snap align to set from `lv_snap_align_t`
  */
-void _lv_obj_scroll_by_raw(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_snap_align_t align);
 
 /**
- * Moves all children with horizontally or vertically.
- * Limits the scroll to the bounding box of the children.
- * @param obj pointer to an object whose children should be moved
- * @param x pixel to move horizontally
- * @param y pixels to move vertically
+ * Set where to snap the children when scrolling ends vertically
+ * @param obj pointer to an object
+ * @param align the snap align to set from `lv_snap_align_t`
  */
-void lv_obj_scroll_by(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_snap_align_t align);
+
+/*=====================
+ * Getter functions
+ *====================*/
 
 /**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
- * @param y the y coordinate to scroll to
+ * Get the current scroll mode (when to hide the scrollbars)
+ * @param obj pointer to an object
+ * @return the current scroll mode from `lv_scroll_mode_t`
  */
-void lv_obj_scroll_to(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj);
 
 /**
- * Scroll the a given x coordinate to the left side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param x the x coordinate to scroll to
+ * Get the object in which directions can be scrolled
+ * @param obj pointer to an object
+ * @param dir the allow scroll directions. An element or OR-ed values of `lv_dir_t`
  */
-void lv_obj_scroll_to_x(struct _lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
+lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj);
 
 /**
- * Scroll the a given y coordinate to the top side of obj.
- * @param obj pointer to an object which should be scrolled
- * @param y the y coordinate to scroll to
+ * Get where to snap the children when scrolling ends horizontally
+ * @param obj pointer to an object
+ * @return the current snap align from `lv_snap_align_t`
  */
-void lv_obj_scroll_to_y(struct _lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
+lv_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj);
 
+/**
+ * Get where to snap the children when scrolling ends vertically
+ * @param obj pointer to an object
+ * @return the current snap align from `lv_snap_align_t`
+ */
+lv_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj);
 
+/**
+ * Get current X scroll position.
+ * @param obj pointer to an object
+ * @return the current scroll position from the left edge.
+ *   If the object is not scrolled return 0
+ *   If scrolled return > 0
+ *   If scrolled in (elastic scroll) return < 0
+ */
 lv_coord_t lv_obj_get_scroll_x(const struct _lv_obj_t * obj);
 
-lv_coord_t lv_obj_get_scroll_y(const struct _lv_obj_t * obj);
 /**
- *
- * Return the height of the area above the parent.
+ * Get current Y scroll position.
+ * @param obj pointer to an object
+ * @return the current scroll position from the top edge.
+ *   If the object is not scrolled return 0
+ *   If scrolled return > 0
+ *   If scrolled inside return < 0
+ */
+lv_coord_t lv_obj_get_scroll_y(const struct _lv_obj_t * obj);
+
+/**
+ * Return the height of the area above the object.
  * That is the number of pixels the object can be scrolled down.
  * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
+ * @param obj pointer to an object
+ * @return the scrollable area above the object in pixels
  */
 lv_coord_t lv_obj_get_scroll_top(struct _lv_obj_t * obj);
 
 /**
- * Return the height of the area below the parent.
- * That is the number of pixels the object can be scrolled up.
+ * Return the height of the area below the object.
+ * That is the number of pixels the object can be scrolled down.
  * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
+ * @param obj pointer to an object
+ * @return the scrollable area below the object in pixels
  */
 lv_coord_t lv_obj_get_scroll_bottom(struct _lv_obj_t * obj);
 
-
 /**
- * Return the weight of the area on the left the parent.
+ * Return the width of the area on the left the object.
  * That is the number of pixels the object can be scrolled down.
  * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
+ * @param obj pointer to an object
+ * @return the scrollable area on the left the object in pixels
  */
 lv_coord_t lv_obj_get_scroll_left(struct _lv_obj_t * obj);
 
 /**
- * Return the width of the area below the object.
- * That is the number of pixels the object can be scrolled left.
+ * Return the width of the area on the right the object.
+ * That is the number of pixels the object can be scrolled down.
  * Normally positive but can be negative when scrolled inside.
- * @param obj
- * @return
+ * @param obj pointer to an object
+ * @return the scrollable area on the right the object in pixels
  */
 lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
 
 /**
- * Get the X and Y coordinates where the scrolling would end for this object if a scrolling animation is in progress.
- * In no scrolling animation give the current `left` or `top` scroll position.
+ * Get the X and Y coordinates where the scrolling will end for this object if a scrolling animation is in progress.
+ * In no scrolling animation give the current `x` or `y` scroll position.
  * @param obj pointer to an object
  * @param end poinr to point to store the result
  */
 void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end);
 
-
-lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj);
-void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir);
-lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj);
-lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj);
-void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
-lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj);
-void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
-
-
 /**********************
  *      MACROS
  **********************/

From 92c23bab9a52a84ce49c08420a974731ae6a4d4a Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 3 Nov 2020 14:14:21 +0100
Subject: [PATCH 74/84] feat(flex): add LV_FLEX_PLACE_STRETCH to support
 stretching items in cross direction

---
 src/lv_core/lv_flex.c | 22 +++++++++++++++-------
 src/lv_core/lv_flex.h |  1 +
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index fb9ad67f5..ef0526366 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -277,6 +277,7 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
     lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
     void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (row ? lv_area_set_width : lv_area_set_height);
+    void (*area_set_cross_size)(lv_area_t *, lv_coord_t) = (!row ? lv_area_set_width : lv_area_set_height);
     lv_coord_t (*area_get_main_size)(const lv_area_t *) = (!row ? lv_area_get_width : lv_area_get_height);
     lv_style_int_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
     lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
@@ -300,16 +301,23 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         }
 
         lv_coord_t main_size = (row ? item->w_set : item->h_set);
-        if(_LV_FLEX_GET_GROW(main_size)) {
-            lv_coord_t s =  _LV_FLEX_GET_GROW(main_size) * grow_unit;
-            s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_end(item, LV_OBJ_PART_MAIN);
-            if(s != area_get_main_size(&item->coords)) {
-                lv_area_t old_coords;
-                lv_area_copy(&old_coords, &item->coords);
-                lv_obj_invalidate(item);
+        if(_LV_FLEX_GET_GROW(main_size) || LV_COORD_GET_FLEX(main_set) == LV_FLEX_PLACE_STRETCH) {
+            lv_area_t old_coords;
+            lv_area_copy(&old_coords, &item->coords);
+
+            if(_LV_FLEX_GET_GROW(main_size)) {
+                lv_coord_t s = _LV_FLEX_GET_GROW(main_size) * grow_unit;
+                s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_end(item, LV_OBJ_PART_MAIN);
                 area_set_main_size(&item->coords, s);
+            }
+            if(LV_COORD_GET_FLEX(main_set) == LV_FLEX_PLACE_STRETCH) {
+                area_set_cross_size(&item->coords, track_size);
+            }
+
+            if(lv_area_get_height(&old_coords) != area_get_main_size(&item->coords)) {
                 lv_obj_invalidate(item);
                 item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
+                lv_obj_invalidate(item);
             }
         }
 
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index 978c475dd..b7169f5f2 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -39,6 +39,7 @@ typedef enum {
     LV_FLEX_PLACE_START,
     LV_FLEX_PLACE_END,
     LV_FLEX_PLACE_CENTER,
+    LV_FLEX_PLACE_STRETCH,
     LV_FLEX_PLACE_SPACE_EVENLY,
     LV_FLEX_PLACE_SPACE_AROUND,
     LV_FLEX_PLACE_SPACE_BETWEEN,

From fab5121ac5b99c3455dbdadf57a2ee17c6b275dd Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 9 Nov 2020 16:14:51 +0100
Subject: [PATCH 75/84] feat(grid): add RTL and margin support

---
 src/lv_core/lv_grid.c    | 91 +++++++++++++++++++++++++++++++---------
 src/lv_core/lv_grid.h    |  7 +++-
 src/lv_core/lv_obj.c     | 12 +++---
 src/lv_core/lv_obj_pos.c |  2 +-
 4 files changed, 84 insertions(+), 28 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index c8a857e63..f0f08884c 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -29,7 +29,7 @@ typedef struct {
 static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
 static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc, item_repos_hint_t * hint);
-static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array);
+static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse);
 static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
 
 /**********************
@@ -44,6 +44,34 @@ static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj);
  *   GLOBAL FUNCTIONS
  **********************/
 
+void lv_grid_init(lv_grid_t * grid)
+{
+    _lv_memset_00(grid,sizeof(lv_grid_t));
+    grid->col_place = LV_GRID_START;
+    grid->row_place = LV_GRID_START;
+}
+
+void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, uint8_t col_cnt, const lv_coord_t * row_dsc, uint8_t row_cnt)
+{
+    grid->col_dsc = col_dsc;
+    grid->col_dsc_len = col_cnt;
+    grid->row_dsc = row_dsc;
+    grid->row_dsc_len = row_cnt;
+}
+
+
+void lv_grid_set_place(lv_grid_t * grid, uint8_t col_place, uint8_t row_place)
+{
+    grid->col_place = col_place;
+    grid->row_place = row_place;
+}
+
+void lv_grid_set_gap(lv_grid_t * grid, lv_coord_t col_gap, uint8_t row_gap)
+{
+    grid->col_gap = col_gap;
+    grid->row_gap = row_gap;
+
+}
 /**
  * Set a grid for an object
  * @param obj pointer to an object
@@ -72,6 +100,10 @@ const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj)
     return NULL;
 }
 
+void lv_obj_set_grid_cell(lv_obj_t * obj, lv_coord_t col_pos, lv_coord_t row_pos)
+{
+    lv_obj_set_pos(obj, col_pos, row_pos);
+}
 
 /**
  * Notify all object if a style is modified
@@ -113,13 +145,14 @@ void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
     calc_rows(cont, calc_out);
     calc_cols(cont, calc_out);
 
+    bool rev = lv_obj_get_base_dir(cont) == LV_BIDI_DIR_RTL ? true : false;
     bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
     lv_coord_t cont_w = lv_obj_get_width_fit(cont);
-    calc_out->grid_w = grid_place(cont_w, auto_w, g->col_place, g->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
+    calc_out->grid_w = grid_place(cont_w, auto_w, g->col_place, g->col_gap, calc_out->col_num, calc_out->w, calc_out->x, rev);
 
     bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
     lv_coord_t cont_h = lv_obj_get_height_fit(cont);
-    calc_out->grid_h = grid_place(cont_h, auto_h, g->row_place, g->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
+    calc_out->grid_h = grid_place(cont_h, auto_h, g->row_place, g->row_gap, calc_out->row_num, calc_out->h, calc_out->y, false);
 
     LV_ASSERT_MEM_INTEGRITY();
 }
@@ -338,52 +371,63 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
     uint8_t x_flag = LV_GRID_GET_CELL_PLACE(item->x_set);
     uint8_t y_flag = LV_GRID_GET_CELL_PLACE(item->y_set);
 
+    /*If the item has RTL base dir switch start and end*/
+    if(lv_obj_get_base_dir(item) == LV_BIDI_DIR_RTL) {
+        if(x_flag == LV_GRID_START) x_flag = LV_GRID_END;
+        else if(x_flag == LV_GRID_END) x_flag = LV_GRID_START;
+    }
+
     lv_coord_t x;
     lv_coord_t y;
-    lv_coord_t w = lv_obj_get_width(item);
-    lv_coord_t h = lv_obj_get_height(item);
+    lv_coord_t item_w = lv_obj_get_width(item);
+    lv_coord_t item_h = lv_obj_get_height(item);
+
+    lv_coord_t margin_top = lv_obj_get_style_margin_top(item, LV_OBJ_PART_MAIN);
+    lv_coord_t margin_bottom = lv_obj_get_style_margin_bottom(item, LV_OBJ_PART_MAIN);
+    lv_coord_t margin_left = lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
+    lv_coord_t margin_right = lv_obj_get_style_margin_right(item, LV_OBJ_PART_MAIN);
 
     switch(x_flag) {
         case LV_GRID_START:
-            x = calc->x[col_pos];
+            x = calc->x[col_pos] + margin_left;
             break;
         case LV_GRID_STRETCH:
-            x = calc->x[col_pos];
-            w = col_w;
+            x = calc->x[col_pos] + margin_left;
+            item_w = col_w - margin_left - margin_right;
             item->w_set = LV_SIZE_STRETCH;
             break;
         case LV_GRID_CENTER:
-            x = calc->x[col_pos] + (col_w - w) / 2;
+            x = calc->x[col_pos] + (col_w - (item_w + margin_left - margin_right)) / 2;
             break;
         case LV_GRID_END:
-            x = calc->x[col_pos + 1] - lv_obj_get_width(item);
+            x = calc->x[col_pos + 1] - lv_obj_get_width(item) - margin_right;
             break;
     }
 
     switch(y_flag) {
         case LV_GRID_START:
-            y = calc->y[row_pos];
+            y = calc->y[row_pos] + margin_top;
             break;
         case LV_GRID_STRETCH:
-            y = calc->y[row_pos];
+            y = calc->y[row_pos] + margin_top;
+            item_h = row_h - margin_top - margin_bottom;
             item->h_set = LV_SIZE_STRETCH;
-            h = row_h;
             break;
         case LV_GRID_CENTER:
-            y = calc->y[row_pos] + (row_h - h) / 2;
+            y = calc->y[row_pos] + (row_h - (item_h + margin_top + margin_bottom)) / 2;
             break;
         case LV_GRID_END:
-            y = calc->y[row_pos + 1] - lv_obj_get_height(item);
+            y = calc->y[row_pos + 1] - lv_obj_get_height(item) - margin_bottom;
             break;
     }
 
     /*Set a new size if required*/
-    if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
+    if(lv_obj_get_width(item) != item_w || lv_obj_get_height(item) != item_h) {
         lv_area_t old_coords;
         lv_area_copy(&old_coords, &item->coords);
         lv_obj_invalidate(item);
-        lv_area_set_width(&item->coords, w);
-        lv_area_set_height(&item->coords, h);
+        lv_area_set_width(&item->coords, item_w);
+        lv_area_set_height(&item->coords, item_h);
         lv_obj_invalidate(item);
         item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
 
@@ -408,10 +452,10 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
  * @param pos_array write the positions of the tracks here
  * @return the total size of the grid
  */
-static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array)
+static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t place, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse)
 {
     lv_coord_t grid_size = 0;
-    uint32_t i;
+    int32_t i;
 
     if(auto_size) {
         pos_array[0] = 0;
@@ -460,6 +504,13 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
         pos_array[i + 1] = pos_array[i] + size_array[i] + gap;
     }
 
+    if(reverse) {
+        for(i = 0; i < track_num; i++) {
+            pos_array[i] = cont_size - pos_array[i] - size_array[i];
+        }
+
+    }
+
     /*Return the full size of the grid*/
     return pos_array[track_num - 1] + size_array[track_num - 1] - pos_array[0];
 }
diff --git a/src/lv_core/lv_grid.h b/src/lv_core/lv_grid.h
index e9c25b2f0..3de13459c 100644
--- a/src/lv_core/lv_grid.h
+++ b/src/lv_core/lv_grid.h
@@ -85,9 +85,11 @@ typedef struct {
 
 void lv_grid_init(lv_grid_t * grid);
 
-void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv_coord_t * row_dsc);
+void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, uint8_t col_cnt, const lv_coord_t * row_dsc, uint8_t row_cnt);
 
-void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
+void lv_grid_set_place(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
+
+void lv_grid_set_gap(lv_grid_t * grid, lv_coord_t col_gap, uint8_t row_gap);
 
 /**
  * Set a grid for an object
@@ -103,6 +105,7 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid);
  */
 const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj);
 
+void lv_obj_set_grid_cell(lv_obj_t * obj, lv_coord_t col_pos, lv_coord_t row_pos);
 
 /**
  * Notify all object if a style is modified
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 4fd045144..4047a7de3 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -48,7 +48,7 @@
 #define LV_OBJX_NAME "lv_obj"
 #define LV_OBJ_DEF_WIDTH    (LV_DPX(100))
 #define LV_OBJ_DEF_HEIGHT   (LV_DPX(50))
-#define GRID_DEBUG  1 /*Draw rectangles on grid cells*/
+#define GRID_DEBUG          0   /*Draw rectangles on grid cells*/
 
 /**********************
  *      TYPEDEFS
@@ -1318,8 +1318,8 @@ lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(obj->spec_attr == NULL) return LV_BIDI_DIR_LTR;
 #if LV_USE_BIDI
+    if(obj->spec_attr == NULL) return LV_BIDI_DIR_LTR;
     const lv_obj_t * parent = obj;
 
     while(parent) {
@@ -1811,15 +1811,17 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
             _lv_grid_calc(obj, &calc);
 
             /*Create a color unique to this object. */
-            lv_color_t c = lv_color_hex(((lv_uintptr_t) obj) & 0xFFFFFF);
+            uint32_t cx = ((lv_uintptr_t) obj) & 0xFFFFFF;
+            cx = (cx & 0xff) ^ ((cx >> 8) & 0xff) ^ ((cx >> 16) & 0xff) ^ ((cx >> 24) & 0xff);
+            lv_color_t c = lv_color_hsv_to_rgb(cx & 0xff, 100, 100);
 
             lv_draw_rect_dsc_t grid_rect_dsc;
             lv_draw_rect_dsc_init(&grid_rect_dsc);
             grid_rect_dsc.bg_color = c;
-            grid_rect_dsc.bg_opa = LV_OPA_20;
+            grid_rect_dsc.bg_opa = LV_OPA_10;
             grid_rect_dsc.border_width = 2;
             grid_rect_dsc.border_color = c;
-            grid_rect_dsc.border_opa = LV_OPA_70;
+            grid_rect_dsc.border_opa = LV_OPA_30;
 
             lv_point_t grid_abs;
             lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN);
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index b40924666..c892cdb95 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -714,7 +714,7 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
 {
     lv_obj_t * cont = lv_obj_get_parent(obj);
     if(cont == NULL) return false;
-    const lv_grid_t * g = lv_obj_get_grid(obj);
+    const lv_grid_t * g = lv_obj_get_grid(cont);
     if(g == NULL) return false;
     if(g->col_dsc == NULL) return false;
     if(g->row_dsc == NULL) return false;

From cfd0968bfe2c70556ce2eda7d6a2ca1eadee3734 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Mon, 9 Nov 2020 19:58:05 +0100
Subject: [PATCH 76/84] fix(grid): fix grid positioning with RTL base diraction

---
 src/lv_core/lv_grid.c    |  8 +++++---
 src/lv_core/lv_obj.c     | 11 -----------
 src/lv_core/lv_obj_pos.c | 32 ++++----------------------------
 3 files changed, 9 insertions(+), 42 deletions(-)

diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index f0f08884c..723f761b3 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -400,7 +400,7 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
             x = calc->x[col_pos] + (col_w - (item_w + margin_left - margin_right)) / 2;
             break;
         case LV_GRID_END:
-            x = calc->x[col_pos + 1] - lv_obj_get_width(item) - margin_right;
+            x = calc->x[col_pos] + col_w - lv_obj_get_width(item) - margin_right;
             break;
     }
 
@@ -417,7 +417,7 @@ static void item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc,
             y = calc->y[row_pos] + (row_h - (item_h + margin_top + margin_bottom)) / 2;
             break;
         case LV_GRID_END:
-            y = calc->y[row_pos + 1] - lv_obj_get_height(item) - margin_bottom;
+            y = calc->y[row_pos] + row_h - lv_obj_get_height(item) - margin_bottom;
             break;
     }
 
@@ -504,6 +504,8 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
         pos_array[i + 1] = pos_array[i] + size_array[i] + gap;
     }
 
+    lv_coord_t total_gird_size = pos_array[track_num - 1] + size_array[track_num - 1] - pos_array[0];
+
     if(reverse) {
         for(i = 0; i < track_num; i++) {
             pos_array[i] = cont_size - pos_array[i] - size_array[i];
@@ -512,7 +514,7 @@ static lv_coord_t grid_place(lv_coord_t cont_size,  bool auto_size, uint8_t plac
     }
 
     /*Return the full size of the grid*/
-    return pos_array[track_num - 1] + size_array[track_num - 1] - pos_array[0];
+    return total_gird_size;
 }
 
 
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 4047a7de3..870a19326 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -1986,17 +1986,6 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
             lv_obj_set_size(obj, obj->w_set, obj->h_set);
         }
-
-        /*If the changed children was a grid item refresh this objects grid*/
-        if(lv_obj_get_grid(obj)) {
-            lv_obj_t * child = param;
-            if(child) {
-                if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
-            } else {
-                _lv_grid_full_refresh(obj);
-            }
-        }
-
     }
     else if(sign == LV_SIGNAL_SCROLL) {
         res = lv_event_send(obj, LV_EVENT_SCROLL, NULL);
diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index c892cdb95..25d58c90a 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -575,7 +575,7 @@ bool _lv_obj_handle_self_size_chg(struct _lv_obj_t * obj)
 }
 
 /**
- * Calculate the "auto size". It's `auto_size = max(gird_size, children_size, self_size)`
+ * Calculate the "auto size". It's `auto_size = max(children_size, self_size)`
  * @param obj pointer to an object
  * @param w_out store the width here. NULL to not calculate width
  * @param h_out store the height here. NULL to not calculate height
@@ -583,42 +583,18 @@ bool _lv_obj_handle_self_size_chg(struct _lv_obj_t * obj)
 void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_out)
 {
     if(!w_out && !h_out) return;
-
-//    printf("auto size\n");
-
-    /*If no other effect the auto-size of zero by default*/
-    if(w_out) *w_out = 0;
-    if(h_out) *h_out = 0;
-
-    /*Get the grid size of the object has a defined grid*/
-    lv_coord_t grid_w = 0;
-    lv_coord_t grid_h = 0;
-    if(lv_obj_get_grid(obj)) {
-        _lv_grid_calc_t calc;
-        _lv_grid_calc(obj, &calc);
-        grid_w = calc.grid_w + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
-        grid_h = calc.grid_h + lv_obj_get_style_pad_top(obj, LV_OBJ_PART_MAIN) +  lv_obj_get_style_pad_bottom(obj, LV_OBJ_PART_MAIN);
-        _lv_grid_calc_free(&calc);
-    }
-
-    /*Get the children's most right and bottom position*/
-    lv_coord_t children_w = 0;
-    lv_coord_t children_h = 0;
+    /*Get the bounding box of the children*/
     if(w_out) {
         lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
         lv_coord_t scroll_left = lv_obj_get_scroll_left(obj);
-        children_w = lv_obj_get_width(obj) + scroll_right + scroll_left;
+        *w_out = lv_obj_get_width(obj) + scroll_right + scroll_left;
     }
 
     if(h_out) {
         lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
         lv_coord_t scroll_top = lv_obj_get_scroll_top(obj);
-        children_h = lv_obj_get_height(obj) + scroll_bottom + scroll_top;
+        *h_out = lv_obj_get_height(obj) + scroll_bottom + scroll_top;
     }
-
-    /*auto_size = max(gird_size, children_size)*/
-    if(w_out) *w_out = LV_MATH_MAX(children_w, grid_w);
-    if(h_out) *h_out = LV_MATH_MAX(children_h, grid_h);
 }
 
 /**

From 1ea0d7845aa432ada81364906ffe9c587aceae70 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:08:12 +0100
Subject: [PATCH 77/84] fix(dropdown): fix incorrect scrolling to the selected
 option

---
 src/lv_widgets/lv_dropdown.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/lv_widgets/lv_dropdown.c b/src/lv_widgets/lv_dropdown.c
index 9f2745709..b8247f72e 100644
--- a/src/lv_widgets/lv_dropdown.c
+++ b/src/lv_widgets/lv_dropdown.c
@@ -559,13 +559,12 @@ void lv_dropdown_open(lv_obj_t * ddlist)
 
     lv_obj_t * label = lv_label_create(ext->list, NULL);
     lv_label_set_text_static(label, ext->options);
+    lv_obj_set_width(ext->list, LV_SIZE_AUTO);
 
     /*Set smaller width to the width of the button*/
-    if(lv_obj_get_width(ext->list) < lv_obj_get_width(ddlist) &&
+    if(lv_obj_get_width(ext->list) < lv_obj_get_width_fit(ddlist) &&
        (ext->dir == LV_DIR_TOP || ext->dir == LV_DIR_BOTTOM)) {
         lv_obj_set_width(ext->list, lv_obj_get_width(ddlist));
-    } else {
-        lv_obj_set_width(ext->list, LV_SIZE_AUTO);
     }
 
     lv_coord_t label_h = lv_obj_get_height(label);
@@ -1198,6 +1197,11 @@ static void position_to_selected(lv_obj_t * ddlist)
 
     lv_coord_t line_y1 = ext->sel_opt_id * (font_h + line_space);
 
+    /*Do not allow scrolling in*/
+    lv_coord_t bottom_diff = ext->list->coords.y2 - lv_obj_get_style_pad_bottom(ext->list, LV_OBJ_PART_MAIN) - (label->coords.y2 - line_y1);
+    if(bottom_diff > 0) line_y1 -= bottom_diff;
+
+    /*Scroll to the selected option*/
     lv_obj_scroll_to_y(ext->list, line_y1, LV_ANIM_OFF);
     lv_obj_invalidate(ext->list);
 }

From 288411a1d360117b6a6833811f7f0f0afc92c310 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:09:28 +0100
Subject: [PATCH 78/84] feat(flex): add item placement in the main direction
 too

---
 src/lv_core/lv_flex.c | 131 ++++++++++++++++++++++++++----------------
 src/lv_core/lv_flex.h |  37 +++++-------
 2 files changed, 94 insertions(+), 74 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index ef0526366..8d9a6fbdb 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -16,13 +16,20 @@
 /**********************
  *      TYPEDEFS
  **********************/
+typedef struct {
+    lv_coord_t grow_unit;
+    lv_coord_t track_cross_size;
+    lv_coord_t track_main_size;
+    uint32_t item_cnt;
+}track_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size);
-static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit);
-static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
+//static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size, lv_coord_t * track_main_size, uint32_t * item_cnt);
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_main_size, track_t * t);
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t max_main_size, lv_flex_place_t main_place, track_t * t);
+static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t item_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
 
 static lv_flex_dir_t get_dir(const lv_obj_t * obj);
 static bool get_rev(const lv_obj_t * obj);
@@ -56,12 +63,16 @@ void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
     _lv_flex_refresh(obj);
 }
 
-void lv_obj_set_flex_track_place(lv_obj_t * obj, lv_flex_place_t place)
+void lv_obj_set_flex_place(lv_obj_t * obj, lv_flex_place_t item_place, lv_flex_place_t track_place)
 {
     lv_obj_allocate_rare_attr(obj);
-    if(obj->spec_attr->flex_cont.place == place) return;
+    if(obj->spec_attr->flex_cont.item_place == item_place &&
+       obj->spec_attr->flex_cont.track_place == track_place) {
+        return;
+    }
 
-    obj->spec_attr->flex_cont.place = place;
+    obj->spec_attr->flex_cont.item_place = item_place;
+    obj->spec_attr->flex_cont.track_place = track_place;
 
     _lv_flex_refresh(obj);
 }
@@ -107,9 +118,15 @@ lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj)
     else return LV_FLEX_DIR_NONE;
 }
 
+lv_flex_place_t lv_obj_get_flex_item_place(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.item_place;
+    else return LV_FLEX_PLACE_START;
+}
+
 lv_flex_place_t lv_obj_get_flex_track_place(const lv_obj_t * obj)
 {
-    if(obj->spec_attr) return obj->spec_attr->flex_cont.place;
+    if(obj->spec_attr) return obj->spec_attr->flex_cont.track_place;
     else return LV_FLEX_PLACE_START;
 }
 
@@ -119,7 +136,7 @@ lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj)
     else return 0;
 }
 
-lv_flex_place_t lv_obj_get_flex_item_place(lv_obj_t * obj)
+lv_flex_place_t lv_obj_get_flex_self_place(lv_obj_t * obj)
 {
     lv_coord_t x = lv_obj_get_x(obj);
     if(LV_COORD_IS_FLEX(x)) return LV_COORD_GET_FLEX(x);
@@ -139,65 +156,65 @@ void _lv_flex_refresh(lv_obj_t * cont)
     lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_y(cont);
     lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_x(cont);
 
-    lv_coord_t place = lv_obj_get_flex_track_place(cont);
+    lv_flex_place_t cross_place = lv_obj_get_flex_track_place(cont);
+    lv_flex_place_t main_place = cont->spec_attr->flex_cont.item_place;
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
 
     if((row && cont->h_set == LV_SIZE_AUTO) ||
        (!row && cont->w_set == LV_SIZE_AUTO))
     {
-        place = LV_FLEX_PLACE_START;
+        cross_place = LV_FLEX_PLACE_START;
     }
 
     if(rtl && !row) {
-        if(place == LV_FLEX_PLACE_START) place = LV_FLEX_PLACE_END;
-        else if(place == LV_FLEX_PLACE_END) place = LV_FLEX_PLACE_START;
+        if(cross_place == LV_FLEX_PLACE_START) cross_place = LV_FLEX_PLACE_END;
+        else if(cross_place == LV_FLEX_PLACE_END) cross_place = LV_FLEX_PLACE_START;
     }
 
-    lv_coord_t all_track_size = 0;
+    lv_coord_t total_track_cross_size = 0;
     lv_coord_t gap = 0;
-    uint32_t row_cnt = 0;
-    lv_coord_t grow_unit;
-    lv_coord_t track_size;
+    uint32_t track_cnt = 0;
     lv_obj_t * track_first_item;
     lv_obj_t * next_track_first_item;
     bool rev = get_rev(cont);
 
-    if(place != LV_FLEX_PLACE_START) {
+    if(cross_place != LV_FLEX_PLACE_START) {
         track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
-
+        track_t t;
         while(track_first_item) {
             /*Search the first item of the next row */
-            next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
-            all_track_size += track_size;
-            row_cnt++;
+            next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &t);
+            total_track_cross_size += t.track_cross_size;
+            track_cnt++;
             track_first_item = next_track_first_item;
         }
 
         lv_coord_t max_cross_size = (row ? lv_obj_get_height_fit(cont) : lv_obj_get_width_fit(cont));
-        place_content(place, max_cross_size, all_track_size,row_cnt, cross_pos, &gap);
+        place_content(cross_place, max_cross_size, total_track_cross_size, track_cnt, cross_pos, &gap);
     }
 
     track_first_item =  rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
 
     if(rtl && !row) {
-         *cross_pos += all_track_size;
+         *cross_pos += total_track_cross_size;
     }
 
     while(track_first_item) {
+        track_t t;
         /*Search the first item of the next row */
-        next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &grow_unit, &track_size);
+        next_track_first_item = find_track_end(cont, track_first_item, max_main_size, &t);
 
         if(rtl && !row) {
-            *cross_pos -= track_size;
+            *cross_pos -= t.track_cross_size;
         }
-        children_repos(cont, track_first_item, next_track_first_item, abs_x, abs_y, track_size, grow_unit);
+        children_repos(cont, track_first_item, next_track_first_item, abs_x, abs_y, max_main_size, main_place, &t);
         track_first_item = next_track_first_item;
 
         if(rtl && !row) {
             *cross_pos -=  gap;
         } else {
-            *cross_pos += track_size + gap;
+            *cross_pos += t.track_cross_size + gap;
         }
     }
     LV_ASSERT_MEM_INTEGRITY();
@@ -207,7 +224,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
  *   STATIC FUNCTIONS
  **********************/
 
-static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
+static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_main_size, track_t * t)
 {
     bool wrap = get_wrap(cont);
     bool rev = get_rev(cont);
@@ -220,10 +237,11 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
 
     lv_coord_t grow_sum = 0;
-    lv_coord_t used_size = 0;
+    t->track_main_size = 0;
     uint32_t grow_item_cnt = 0;
-    *track_cross_size = 0;
-    *grow_unit = 0;
+    t->track_cross_size = 0;
+    t->grow_unit = 0;
+    t->item_cnt = 0;
 
     lv_obj_t * item = item_start;
     while(item) {
@@ -240,35 +258,41 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
             grow_item_cnt++;
         } else {
             lv_coord_t item_size = get_main_size(item) + gap;
-            if(wrap && used_size + item_size > max_size) break;
-            used_size += item_size;
+            if(wrap && t->track_main_size + item_size > max_main_size) break;
+            t->track_main_size += item_size;
         }
-        *track_cross_size = LV_MATH_MAX(get_cross_size(item), *track_cross_size);
+        t->track_cross_size = LV_MATH_MAX(get_cross_size(item), t->track_cross_size);
 
         item = ll_iter(ll, item);
+        t->item_cnt++;
     }
 
-    if(used_size > 0) used_size -= gap; /*There is no gap after the last item*/
+    if(t->track_main_size > 0) t->track_main_size -= gap; /*There is no gap after the last item*/
 
     if(grow_item_cnt && grow_sum) {
-        lv_coord_t s = max_size - used_size;
+        lv_coord_t s = max_main_size - t->track_main_size;
         s -= grow_item_cnt * gap;
-        *grow_unit =  s / grow_sum;
+        t->grow_unit =  s / grow_sum;
+        t->track_main_size = max_main_size;  /*If there is at least one "grow item" the track takes the full space*/
     } else {
-        *grow_unit = 0;
+        t->grow_unit = 0;
     }
 
     /*Have at least one item in a row*/
     if(item && item == item_start) {
         item = ll_iter(ll, item);
-        if(item) *track_cross_size = get_cross_size(item);
+        if(item) {
+            t->track_cross_size = get_cross_size(item);
+            t->track_main_size = get_main_size(item);
+            t->item_cnt = 1;
+        }
     }
 
     return item;
 }
 
 
-static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
+static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t max_main_size, lv_flex_place_t main_place, track_t * t)
 {
     bool rev = get_rev(cont);
     lv_coord_t gap = lv_obj_get_flex_gap(cont);
@@ -289,6 +313,9 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
 
     lv_ll_t * ll = _lv_obj_get_child_ll(cont);
     lv_coord_t main_pos = 0;
+
+    lv_coord_t place_gap;
+    place_content(main_place, max_main_size, t->track_main_size, t->item_cnt, &main_pos, &place_gap);
     /*Reposition the children*/
     lv_obj_t * item = item_first;   /*Just to use a shorter name*/
     while(item != item_last) {
@@ -306,12 +333,12 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
             lv_area_copy(&old_coords, &item->coords);
 
             if(_LV_FLEX_GET_GROW(main_size)) {
-                lv_coord_t s = _LV_FLEX_GET_GROW(main_size) * grow_unit;
+                lv_coord_t s = _LV_FLEX_GET_GROW(main_size) * t->grow_unit;
                 s -= get_margin_start(item, LV_OBJ_PART_MAIN) + get_margin_end(item, LV_OBJ_PART_MAIN);
                 area_set_main_size(&item->coords, s);
             }
             if(LV_COORD_GET_FLEX(main_set) == LV_FLEX_PLACE_STRETCH) {
-                area_set_cross_size(&item->coords, track_size);
+                area_set_cross_size(&item->coords, t->track_cross_size);
             }
 
             if(lv_area_get_height(&old_coords) != area_get_main_size(&item->coords)) {
@@ -325,15 +352,15 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         lv_coord_t cross_set = (row ? item->y_set : item->x_set);
         switch(LV_COORD_GET_FLEX(cross_set)) {
         case LV_FLEX_PLACE_CENTER:
-            cross_pos = (track_size - obj_get_cross_size(item)) / 2;
+            cross_pos = (t->track_cross_size - obj_get_cross_size(item)) / 2;
             break;
         case LV_FLEX_PLACE_END:
-            cross_pos = track_size - obj_get_cross_size(item);
+            cross_pos = t->track_cross_size - obj_get_cross_size(item);
             break;
         }
 
         if(row && rtl) {
-            main_pos -= obj_get_main_size(item) + gap;
+            main_pos -= obj_get_main_size(item) + gap + place_gap;
         }
 
         lv_coord_t diff_x = abs_x - item->coords.x1 + lv_obj_get_style_margin_left(item, LV_OBJ_PART_MAIN);
@@ -350,15 +377,15 @@ static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * it
         }
 
         if(!(row && rtl)) {
-            main_pos += obj_get_main_size(item) + gap;
+            main_pos += obj_get_main_size(item) + gap + place_gap;
         }
         item = ll_iter(ll, item);
     }
 }
 
-static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t track_cnt, lv_coord_t * start_pos, lv_coord_t * gap)
+static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t track_size, lv_coord_t item_cnt, lv_coord_t * start_pos, lv_coord_t * gap)
 {
-    if(track_cnt <= 1) {
+    if(item_cnt <= 1) {
         switch(place) {
             case LV_FLEX_PLACE_SPACE_BETWEEN:
             case LV_FLEX_PLACE_SPACE_AROUND:
@@ -370,20 +397,22 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
 
     switch(place) {
     case LV_FLEX_PLACE_CENTER:
+        *gap = 0;
         *start_pos += (max_size - track_size) / 2;
         break;
     case LV_FLEX_PLACE_END:
+        *gap = 0;
         *start_pos += max_size - track_size;
         break;
     case LV_FLEX_PLACE_SPACE_BETWEEN:
-       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt - 1);
+       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(item_cnt - 1);
        break;
    case LV_FLEX_PLACE_SPACE_AROUND:
-       *gap += (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt);
+       *gap += (lv_coord_t)(max_size - track_size) / (lv_coord_t)(item_cnt);
        *start_pos += *gap / 2;
        break;
    case LV_FLEX_PLACE_SPACE_EVENLY:
-       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(track_cnt + 1);
+       *gap = (lv_coord_t)(max_size - track_size) / (lv_coord_t)(item_cnt + 1);
        *start_pos += *gap;
        break;
    default:
diff --git a/src/lv_core/lv_flex.h b/src/lv_core/lv_flex.h
index b7169f5f2..a8c31e02f 100644
--- a/src/lv_core/lv_flex.h
+++ b/src/lv_core/lv_flex.h
@@ -62,7 +62,8 @@ typedef struct {
     uint8_t dir        :2;
     uint8_t wrap       :1;
     uint8_t rev        :1;
-    uint8_t place      :3;
+    uint8_t item_place      :3;
+    uint8_t track_place      :3;
 }lv_flex_cont_t;
 
 /**********************
@@ -83,24 +84,13 @@ typedef struct {
 void lv_obj_set_flex_dir(struct _lv_obj_t * obj, lv_flex_dir_t flex_dir);
 
 /**
- * Set how to place the tracks below/next to each other.
- * For ROW direction it means how to place the rows vertically.
- * For COLUMN direction it means how to place the column horizontally.
+ * Set how to place the items and the tracks
  * @param obj point to a flex container
- * @param place the placement type. Can be any element of `lv_flex_place_t`.
+ * @param item_place tells how to distribute the free space among the items in the same track
+ * @param track_place tells how to distribute the free space among the tracks
  * @note if the base direction is RTL and the direction is ROW, LV_FLEX_START means the right side
  */
-void lv_obj_set_flex_track_place(struct _lv_obj_t * obj, lv_flex_place_t place);
-
-/**
- * Set a gap in the main direction.
- * For ROW direction it means adding gap horizontally between the items.
- * For COLUMN direction it means adding gap vertically between the items.
- * @param obj pointer to an object (flex container)
- * @param gap the gap in pixels
- * @note By default the objects are packed tightly after each other
- */
-void lv_obj_set_flex_gap(struct _lv_obj_t * obj, lv_coord_t gap);
+void lv_obj_set_flex_place(struct _lv_obj_t * obj, lv_flex_place_t item_place, lv_flex_place_t track_place);
 
 /**
  * Make an object flex item, i.e. allow setting it's coordinate according to the parent's flex settings.
@@ -132,18 +122,19 @@ void lv_obj_set_flex_item_place(struct _lv_obj_t * obj, lv_flex_place_t place);
  */
 lv_flex_dir_t lv_obj_get_flex_dir(const struct _lv_obj_t * obj);
 
+/**
+ * Get the item placement of a flex container
+ * @param obj pointer to an object
+ * @return the item placement
+ */
+lv_flex_place_t lv_obj_get_flex_item_place(const struct _lv_obj_t * obj);
+
 /**
  * Get the track placement of a flex container
  * @param obj pointer to an object
  * @return the track placement
  */
 lv_flex_place_t lv_obj_get_flex_track_place(const struct _lv_obj_t * obj);
-/**
- * Get flex gap
- * @param obj pointer to an flex container
- * @return the gap in pixels
- */
-lv_coord_t lv_obj_get_flex_gap(const struct _lv_obj_t * obj);
 
 /**
  * Get how the flex item is placed in its track in the cross direction.
@@ -152,7 +143,7 @@ lv_coord_t lv_obj_get_flex_gap(const struct _lv_obj_t * obj);
  * @param obj pointer to a flex item
  * @return `LV_FLEX_PLACE_NONE/START/CENTER/END`
  */
-lv_flex_place_t lv_obj_get_flex_item_place(struct _lv_obj_t * obj);
+lv_flex_place_t lv_obj_get_flex_self_place(struct _lv_obj_t * obj);
 /**
  * Rearrange the flex items of a flex container
  * @param cont pointer to a flex container object

From a69d5d08df5986aac27b07ff94406e21fba37fac Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:10:06 +0100
Subject: [PATCH 79/84] fix(draw): handle opa_scale on scrollbars

---
 src/lv_core/lv_obj_draw.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index 2481bc7c5..86cbf84b5 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -568,6 +568,12 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
         }
     }
 
+    lv_opa_t opa_scale = lv_obj_get_style_opa_scale(obj, LV_OBJ_PART_MAIN);
+    if(opa_scale < LV_OPA_MAX) {
+        dsc->bg_opa = (dsc->bg_opa * opa_scale) >> 8;
+        dsc->border_opa = (dsc->bg_opa * opa_scale) >> 8;
+    }
+
     if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP) {
         dsc->radius = lv_obj_get_style_scrollbar_radius(obj, LV_OBJ_PART_MAIN);
         return LV_RES_OK;

From 9a926aa2f062a36798b7a9cc72a0a0a7751887f0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:11:10 +0100
Subject: [PATCH 80/84] fix(copy): fix copying spec_attrs in lv_obj_create

---
 src/lv_core/lv_obj.c | 62 +++++++++++++++++++++++++-------------------
 1 file changed, 35 insertions(+), 27 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 870a19326..b653b2024 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -265,34 +265,40 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
     lv_style_list_init(&new_obj->style_list);
     lv_style_list_init(&new_obj->style_list);
-     if(copy == NULL) {
-         if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
-         else  lv_theme_apply(new_obj, LV_THEME_SCR);
-     }
-     else {
-         lv_style_list_copy(&new_obj->style_list, &copy->style_list);
-     }
-     /*Copy the attributes if required*/
-     if(copy != NULL) {
-         lv_area_copy(&new_obj->coords, &copy->coords);
-         new_obj->ext_draw_pad = copy->ext_draw_pad;
+    if(copy == NULL) {
+        if(parent != NULL) lv_theme_apply(new_obj, LV_THEME_OBJ);
+        else  lv_theme_apply(new_obj, LV_THEME_SCR);
+    }
+    else {
+        lv_style_list_copy(&new_obj->style_list, &copy->style_list);
+    }
+    /*Copy the attributes if required*/
+    if(copy != NULL) {
+        lv_area_copy(&new_obj->coords, &copy->coords);
+        new_obj->ext_draw_pad = copy->ext_draw_pad;
 
-         new_obj->flags  = copy->flags;
+        new_obj->flags  = copy->flags;
+        if(copy->spec_attr) {
+            lv_obj_allocate_rare_attr(new_obj);
+            _lv_memcpy_small(new_obj->spec_attr, copy->spec_attr, sizeof(lv_obj_spec_attr_t));
+        }
+#if LV_USE_GROUP
+        /*Add to the same group*/
+        if(copy->spec_attr && copy->spec_attr->group_p) {
+            new_obj->spec_attr->group_p = NULL; /*It was simply copied */
+            lv_group_add_obj(copy->spec_attr->group_p, new_obj);
+        }
+#endif
 
- #if LV_USE_GROUP
-         /*Add to the same group*/
-         if(copy->spec_attr && copy->spec_attr->group_p) {
-             lv_group_add_obj(copy->spec_attr->group_p, new_obj);
-         }
- #endif
-
-         /*Set the same coordinates for non screen objects*/
-         if(lv_obj_get_parent(copy) != NULL && parent != NULL) {
-             lv_obj_set_pos(new_obj, lv_obj_get_x(copy), lv_obj_get_y(copy));
-         }
-     }
-    lv_obj_set_pos(new_obj, 0, 0);
+        /*Set the same coordinates for non screen objects*/
+        if(lv_obj_get_parent(copy) != NULL && parent != NULL) {
+            lv_obj_set_pos(new_obj, lv_obj_get_x(copy), lv_obj_get_y(copy));
+            lv_obj_set_size(new_obj, lv_obj_get_width(copy), lv_obj_get_height(copy));
 
+        }
+    } else {
+        lv_obj_set_pos(new_obj, 0, 0);
+    }
     /*Send a signal to the parent to notify it about the new child*/
     if(parent != NULL) {
         parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, new_obj);
@@ -2001,10 +2007,12 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
-        if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
-
+        if(_lv_obj_is_grid_item(obj)) lv_grid_item_refr_pos(obj);
         if(lv_obj_get_grid(obj)) _lv_grid_full_refresh(obj);
 
+        if(_lv_obj_is_flex_item(obj)) _lv_flex_refresh(lv_obj_get_parent(obj));
+        if(lv_obj_get_flex_dir(obj)) _lv_flex_refresh(obj);
+
         /*Reposition non grid objects on by one*/
         lv_obj_t * child;
 

From dd7a392023fb0d0a544f1d4e2c0e05f2a64cf55f Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:16:13 +0100
Subject: [PATCH 81/84] fix(lv_obj_scroll): add missing function declarations
 in header

---
 src/lv_core/lv_obj_scroll.h | 53 +++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/src/lv_core/lv_obj_scroll.h b/src/lv_core/lv_obj_scroll.h
index f4b561eaf..6e15100df 100644
--- a/src/lv_core/lv_obj_scroll.h
+++ b/src/lv_core/lv_obj_scroll.h
@@ -49,6 +49,10 @@ typedef uint8_t lv_snap_align_t;
  * GLOBAL PROTOTYPES
  **********************/
 
+/*=====================
+ * Setter functions
+ *====================*/
+
 /**
  * Set how the scrollbars should behave.
  * @param obj pointer to an object
@@ -173,6 +177,55 @@ lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
  */
 void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end);
 
+/*=====================
+ * Other functions
+ *====================*/
+
+/**
+ * The most basic function to scroll by a given amount of pixels
+ * @param obj pointer to an object to scroll
+ * @param x pixels to scroll horizontally
+ * @param y pixels to scroll vertically
+ * @note > 0 value means scroll right/bottom (show the right/bottom content)
+ */
+void _lv_obj_scroll_by_raw(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
+
+/**
+ *
+ * Scroll by a given amount of pixels
+ * @param obj pointer to an object to scroll
+ * @param x pixels to scroll horizontally
+ * @param y pixels to scroll vertically
+ * @param anim_en LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ * @note > 0 value means scroll right/bottom (show the right/bottom content)
+ */
+void lv_obj_scroll_by(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to a given coordinate on an object
+ * @param obj pointer to an object to scroll
+ * @param x pixels to scroll horizontally
+ * @param y pixels to scroll vertically
+ * @param anim_en LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to a given X coordinate on an object
+ * @param obj pointer to an object to scroll
+ * @param x pixels to scroll horizontally
+ * @param anim_en LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_x(struct _lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en);
+
+/**
+ * Scroll to a given X coordinate on an object
+ * @param obj pointer to an object to scroll
+ * @param y pixels to scroll vertically
+ * @param anim_en LV_ANIM_ON: scroll with animation; LV_ANIM_OFF: scroll immediately
+ */
+void lv_obj_scroll_to_y(struct _lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en);
+
 /**********************
  *      MACROS
  **********************/

From d06aa859c984248ad15d39b5fdd60253ae7db6db Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Tue, 10 Nov 2020 16:16:58 +0100
Subject: [PATCH 82/84] fix(flex): correctly handle setting the size of
 streched flex items

---
 src/lv_core/lv_obj_pos.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/lv_core/lv_obj_pos.c b/src/lv_core/lv_obj_pos.c
index 25d58c90a..8189ac170 100644
--- a/src/lv_core/lv_obj_pos.c
+++ b/src/lv_core/lv_obj_pos.c
@@ -122,12 +122,19 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
     bool x_stretch = false;
     bool y_stretch = false;
 
+    /*Use `LV_SIZE_STRETCH` value if the layout changes the size of the object*/
     if(gi) {
-        x_stretch = LV_GRID_GET_CELL_PLACE(obj->x_set) == LV_GRID_STRETCH ? true : false;
-        y_stretch = LV_GRID_GET_CELL_PLACE(obj->y_set) == LV_GRID_STRETCH ? true : false;
-        if(x_stretch) w = LV_SIZE_STRETCH;
-        if(y_stretch) h = LV_SIZE_STRETCH;
+        if(LV_GRID_GET_CELL_PLACE(obj->x_set)) x_stretch = true;
+        if(LV_GRID_GET_CELL_PLACE(obj->y_set)) y_stretch = true;
     }
+    if(fi) {
+        lv_obj_t * parent = lv_obj_get_parent(obj);
+        if(parent->spec_attr->flex_cont.dir == LV_FLEX_DIR_ROW && LV_COORD_GET_FLEX(obj->y_set) == LV_FLEX_PLACE_STRETCH) y_stretch = true;
+        if(parent->spec_attr->flex_cont.dir == LV_FLEX_DIR_COLUMN && LV_COORD_GET_FLEX(obj->x_set) == LV_FLEX_PLACE_STRETCH) x_stretch = true;
+    }
+
+    if(x_stretch) w = LV_SIZE_STRETCH;
+    if(y_stretch) h = LV_SIZE_STRETCH;
 
     obj->w_set = w;
     obj->h_set = h;

From 65fc61c9c0a0d80fc15f5a84082fda0b9b95c9ef Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 13 Nov 2020 23:04:46 +0100
Subject: [PATCH 83/84] perf(obj): move ext_draw_pad to spec_attrs

It saves some memory becasue it's rarly used any by default evaluated as zero.
---
 src/lv_core/lv_obj.c       | 23 +++++++++++++++--------
 src/lv_core/lv_obj.h       | 13 +++++++++----
 src/lv_core/lv_obj_draw.c  | 14 ++++++++++++--
 src/lv_core/lv_refr.c      |  4 ++--
 src/lv_widgets/lv_bar.c    |  3 ++-
 src/lv_widgets/lv_img.c    | 19 ++++++++++---------
 src/lv_widgets/lv_imgbtn.c |  9 +++++----
 src/lv_widgets/lv_line.c   |  3 ++-
 src/lv_widgets/lv_roller.c |  3 ++-
 src/lv_widgets/lv_slider.c |  3 ++-
 src/lv_widgets/lv_switch.c |  3 ++-
 11 files changed, 63 insertions(+), 34 deletions(-)

diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index b653b2024..850cfeb97 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -247,9 +247,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         new_obj->h_set = lv_area_get_height(&new_obj->coords);
     }
 
-
-    new_obj->ext_draw_pad = 0;
-
     /*Set attributes*/
     new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
     new_obj->flags |= LV_OBJ_FLAG_SNAPABLE;
@@ -275,7 +272,6 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     /*Copy the attributes if required*/
     if(copy != NULL) {
         lv_area_copy(&new_obj->coords, &copy->coords);
-        new_obj->ext_draw_pad = copy->ext_draw_pad;
 
         new_obj->flags  = copy->flags;
         if(copy->spec_attr) {
@@ -411,7 +407,7 @@ void lv_obj_invalidate(const lv_obj_t * obj)
 
     /*Truncate the area to the object*/
     lv_area_t obj_coords;
-    lv_coord_t ext_size = obj->ext_draw_pad;
+    lv_coord_t ext_size = _lv_obj_get_ext_draw_pad(obj);
     lv_area_copy(&obj_coords, &obj->coords);
     obj_coords.x1 -= ext_size;
     obj_coords.y1 -= ext_size;
@@ -442,7 +438,7 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
 
         /*Truncate the area to the object*/
         lv_area_t obj_coords;
-        lv_coord_t ext_size = obj->ext_draw_pad;
+        lv_coord_t ext_size = _lv_obj_get_ext_draw_pad(obj);
         lv_area_copy(&obj_coords, &obj->coords);
         obj_coords.x1 -= ext_size;
         obj_coords.y1 -= ext_size;
@@ -478,7 +474,7 @@ bool lv_obj_is_visible(const lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
     lv_area_t obj_coords;
-    lv_coord_t ext_size = obj->ext_draw_pad;
+    lv_coord_t ext_size = _lv_obj_get_ext_draw_pad(obj);
     lv_area_copy(&obj_coords, &obj->coords);
     obj_coords.x1 -= ext_size;
     obj_coords.y1 -= ext_size;
@@ -644,6 +640,16 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
 #endif
 }
 
+/**
+ * Get the extended draw area of an object.
+ * @param obj pointer to an object
+ * @return the size extended draw area around the real coordinates
+ */
+lv_coord_t _lv_obj_get_ext_draw_pad(const lv_obj_t * obj)
+{
+    if(obj->spec_attr) return obj->spec_attr->ext_draw_pad;
+    else return 0;
+}
 /*---------------------
  * Appearance set
  *--------------------*/
@@ -2003,8 +2009,9 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
         }
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
+        lv_coord_t * s = param;
         lv_coord_t d = _lv_obj_get_draw_rect_ext_pad_size(obj, LV_OBJ_PART_MAIN);
-        obj->ext_draw_pad = LV_MATH_MAX(obj->ext_draw_pad, d);
+        *s = LV_MATH_MAX(*s, d);
     }
     else if(sign == LV_SIGNAL_STYLE_CHG) {
         if(_lv_obj_is_grid_item(obj)) lv_grid_item_refr_pos(obj);
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index 5648044a8..ae0e18e54 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -211,6 +211,7 @@ typedef struct {
 
     lv_flex_cont_t flex_cont;
     lv_point_t scroll; /**< The current X/Y scroll offset*/
+    lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
     uint8_t ext_click_pad; /**< Extra click padding in all direction */
@@ -230,7 +231,6 @@ struct _lv_obj_t {
     lv_obj_spec_attr_t * spec_attr;
     struct _lv_obj_t * parent; /**< Pointer to the parent object*/
 
-    lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
 
     lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
     lv_design_cb_t design_cb; /**< Object type specific design function*/
@@ -240,15 +240,13 @@ struct _lv_obj_t {
 
     /*Attributes and states*/
     lv_obj_flag_t flags;
-
     lv_state_t state;
 
+    lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
     lv_coord_t x_set;
     lv_coord_t y_set;
     lv_coord_t w_set;
     lv_coord_t h_set;
-
-    lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 };
 
 enum {
@@ -409,6 +407,13 @@ void lv_obj_move_background(lv_obj_t * obj);
  */
 void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right, lv_coord_t top, lv_coord_t bottom);
 
+/**
+ * Get the extended draw area of an object.
+ * @param obj pointer to an object
+ * @return the size extended draw area around the real coordinates
+ */
+lv_coord_t _lv_obj_get_ext_draw_pad(const lv_obj_t * obj);
+
 /*---------------------
  * Appearance set
  *--------------------*/
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index 86cbf84b5..643ddb983 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -385,9 +385,19 @@ void _lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    obj->ext_draw_pad = 0;
-    obj->signal_cb(obj, LV_SIGNAL_REFR_EXT_DRAW_PAD, NULL);
+    lv_coord_t s = 0;
+    obj->signal_cb(obj, LV_SIGNAL_REFR_EXT_DRAW_PAD, &s);
 
+    /*Store the result if the special attrs already allocated*/
+    if(obj->spec_attr) {
+        obj->spec_attr = s;
+    }
+    /* Allocate spec. attrs. only if the result is not zero.
+     * Zero is the default value if the spec. attr. are not defined. */
+    else if(s != 0) {
+        lv_obj_allocate_rare_attr(obj);
+        obj->spec_attr->ext_draw_pad = s;
+    }
 }
 
 /**
diff --git a/src/lv_core/lv_refr.c b/src/lv_core/lv_refr.c
index ce8119808..cb554fcf9 100644
--- a/src/lv_core/lv_refr.c
+++ b/src/lv_core/lv_refr.c
@@ -664,7 +664,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
     lv_area_t obj_mask;
     lv_area_t obj_ext_mask;
     lv_area_t obj_area;
-    lv_coord_t ext_size = obj->ext_draw_pad;
+    lv_coord_t ext_size = _lv_obj_get_ext_draw_pad(obj);
     lv_obj_get_coords(obj, &obj_area);
     obj_area.x1 -= ext_size;
     obj_area.y1 -= ext_size;
@@ -705,7 +705,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
             lv_ll_t * ll = _lv_obj_get_child_ll(obj);
             _LV_LL_READ_BACK(ll, child_p) {
                 lv_obj_get_coords(child_p, &child_area);
-                ext_size = child_p->ext_draw_pad;
+                ext_size = _lv_obj_get_ext_draw_pad(child_p);
                 child_area.x1 -= ext_size;
                 child_area.y1 -= ext_size;
                 child_area.x2 += ext_size;
diff --git a/src/lv_widgets/lv_bar.c b/src/lv_widgets/lv_bar.c
index 6b3daba42..81615b8bd 100644
--- a/src/lv_widgets/lv_bar.c
+++ b/src/lv_widgets/lv_bar.c
@@ -631,7 +631,8 @@ static lv_res_t lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
         indic_size = _lv_obj_get_draw_rect_ext_pad_size(bar, LV_BAR_PART_INDIC);
 
         /*Bg size is handled by lv_obj*/
-        bar->ext_draw_pad = LV_MATH_MAX(bar->ext_draw_pad, indic_size);
+        lv_coord_t * s = param;
+        *s = LV_MATH_MAX(*s, indic_size);
 
     }
     if(sign == LV_SIGNAL_CLEANUP) {
diff --git a/src/lv_widgets/lv_img.c b/src/lv_widgets/lv_img.c
index ee1fbc0f7..94c4967b3 100644
--- a/src/lv_widgets/lv_img.c
+++ b/src/lv_widgets/lv_img.c
@@ -754,6 +754,7 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
 
+        lv_coord_t * s = param;
         lv_style_int_t transf_zoom = lv_obj_get_style_transform_zoom(img, LV_IMG_PART_MAIN);
         transf_zoom = (transf_zoom * ext->zoom) >> 8;
 
@@ -766,11 +767,11 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
             lv_coord_t w = lv_obj_get_width(img);
             lv_coord_t h = lv_obj_get_height(img);
             _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, transf_zoom, &ext->pivot);
-            lv_coord_t pad_ori = img->ext_draw_pad;
-            img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, pad_ori - a.x1);
-            img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, pad_ori - a.y1);
-            img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, pad_ori + a.x2 - w);
-            img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, pad_ori + a.y2 - h);
+            lv_coord_t pad_ori = *s;
+            *s = LV_MATH_MAX(*s, pad_ori - a.x1);
+            *s = LV_MATH_MAX(*s, pad_ori - a.y1);
+            *s = LV_MATH_MAX(*s, pad_ori + a.x2 - w);
+            *s = LV_MATH_MAX(*s, pad_ori + a.y2 - h);
         }
 
         /*Handle the padding of the background*/
@@ -779,10 +780,10 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
         lv_style_int_t top = lv_obj_get_style_pad_top(img, LV_IMG_PART_MAIN);
         lv_style_int_t bottom = lv_obj_get_style_pad_bottom(img, LV_IMG_PART_MAIN);
 
-        img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, left);
-        img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, right);
-        img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, top);
-        img->ext_draw_pad = LV_MATH_MAX(img->ext_draw_pad, bottom);
+        *s = LV_MATH_MAX(*s, left);
+        *s = LV_MATH_MAX(*s, right);
+        *s = LV_MATH_MAX(*s, top);
+        *s = LV_MATH_MAX(*s, bottom);
     }
     else if(sign == LV_SIGNAL_HIT_TEST) {
         lv_hit_test_info_t * info = param;
diff --git a/src/lv_widgets/lv_imgbtn.c b/src/lv_widgets/lv_imgbtn.c
index 3dca1c9e2..e3f453c8e 100644
--- a/src/lv_widgets/lv_imgbtn.c
+++ b/src/lv_widgets/lv_imgbtn.c
@@ -465,10 +465,11 @@ static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * par
         lv_style_int_t top = lv_obj_get_style_pad_top(imgbtn, LV_IMGBTN_PART_MAIN);
         lv_style_int_t bottom = lv_obj_get_style_pad_bottom(imgbtn, LV_IMGBTN_PART_MAIN);
 
-        imgbtn->ext_draw_pad = LV_MATH_MAX(imgbtn->ext_draw_pad, left);
-        imgbtn->ext_draw_pad = LV_MATH_MAX(imgbtn->ext_draw_pad, right);
-        imgbtn->ext_draw_pad = LV_MATH_MAX(imgbtn->ext_draw_pad, top);
-        imgbtn->ext_draw_pad = LV_MATH_MAX(imgbtn->ext_draw_pad, bottom);
+        lv_coord_t * s = param;
+        *s = LV_MATH_MAX(*s, left);
+        *s = LV_MATH_MAX(*s, right);
+        *s = LV_MATH_MAX(*s, top);
+        *s = LV_MATH_MAX(*s, bottom);
     }
     else if(sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST) {
         refr_img(imgbtn);
diff --git a/src/lv_widgets/lv_line.c b/src/lv_widgets/lv_line.c
index 642edfc6d..a40eb5b3b 100644
--- a/src/lv_widgets/lv_line.c
+++ b/src/lv_widgets/lv_line.c
@@ -237,7 +237,8 @@ static lv_res_t lv_line_signal(lv_obj_t * line, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         /*The corner of the skew lines is out of the intended area*/
         lv_style_int_t line_width = lv_obj_get_style_line_width(line, LV_LINE_PART_MAIN);
-        if(line->ext_draw_pad < line_width) line->ext_draw_pad = line_width;
+        lv_coord_t * s = param;
+        if(*s < line_width) *s = line_width;
     }
     else if(sign == LV_SIGNAL_GET_SELF_SIZE) {
         lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
diff --git a/src/lv_widgets/lv_roller.c b/src/lv_widgets/lv_roller.c
index 31109fd71..d3ac5a908 100644
--- a/src/lv_widgets/lv_roller.c
+++ b/src/lv_widgets/lv_roller.c
@@ -703,10 +703,11 @@ static lv_res_t lv_roller_label_signal(lv_obj_t * label, lv_signal_t sign, void
 
     if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         /*If the selected text has a larger font it needs some extra space to draw it*/
+        lv_coord_t * s = param;
         lv_obj_t * roller = lv_obj_get_parent(label);
         lv_coord_t sel_w = get_selected_label_width(roller);
         lv_coord_t label_w = lv_obj_get_width(label);
-        label->ext_draw_pad = LV_MATH_MAX(label->ext_draw_pad, sel_w - label_w);
+        *s = LV_MATH_MAX(*s, sel_w - label_w);
     }
 
     return res;
diff --git a/src/lv_widgets/lv_slider.c b/src/lv_widgets/lv_slider.c
index 5f1d98154..2dfff6bb5 100644
--- a/src/lv_widgets/lv_slider.c
+++ b/src/lv_widgets/lv_slider.c
@@ -404,7 +404,8 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
         knob_size += _lv_obj_get_draw_rect_ext_pad_size(slider, LV_SLIDER_PART_KNOB);
 
         /*Indic. size is handled by bar*/
-        slider->ext_draw_pad = LV_MATH_MAX(slider->ext_draw_pad, knob_size);
+        lv_coord_t * s = param;
+        *s  = LV_MATH_MAX(*s, knob_size);
 
     }
     else if(sign == LV_SIGNAL_CONTROL) {
diff --git a/src/lv_widgets/lv_switch.c b/src/lv_widgets/lv_switch.c
index effcdfd5a..36fcb8772 100644
--- a/src/lv_widgets/lv_switch.c
+++ b/src/lv_widgets/lv_switch.c
@@ -314,7 +314,8 @@ static lv_res_t lv_switch_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
         knob_size += _lv_obj_get_draw_rect_ext_pad_size(sw, LV_SWITCH_PART_KNOB);
 
         /*Indic. size is handled by bar*/
-        sw->ext_draw_pad = LV_MATH_MAX(sw->ext_draw_pad, knob_size);
+        lv_coord_t * s = param;
+        *s = LV_MATH_MAX(*s, knob_size);
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
 #if LV_USE_GROUP

From 263c04d7fd920171888cb1c3e6bf31b33fb864c0 Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 13 Nov 2020 23:05:38 +0100
Subject: [PATCH 84/84] refactor: rename lv_obj_allocate_rare_attr to
 lv_obj_allocate_spec_attr

---
 src/lv_core/lv_flex.c       |  6 +++---
 src/lv_core/lv_grid.c       |  2 +-
 src/lv_core/lv_group.c      |  2 +-
 src/lv_core/lv_obj.c        | 18 +++++++++---------
 src/lv_core/lv_obj.h        |  2 +-
 src/lv_core/lv_obj_draw.c   |  2 +-
 src/lv_core/lv_obj_scroll.c | 10 +++++-----
 7 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/lv_core/lv_flex.c b/src/lv_core/lv_flex.c
index 8d9a6fbdb..b10f04c78 100644
--- a/src/lv_core/lv_flex.c
+++ b/src/lv_core/lv_flex.c
@@ -53,7 +53,7 @@ static bool get_wrap(const lv_obj_t * obj);
 
 void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
 {
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
 
     if(obj->spec_attr->flex_cont.dir == flex_dir) return;
 
@@ -65,7 +65,7 @@ void lv_obj_set_flex_dir(lv_obj_t * obj, lv_flex_dir_t flex_dir)
 
 void lv_obj_set_flex_place(lv_obj_t * obj, lv_flex_place_t item_place, lv_flex_place_t track_place)
 {
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
     if(obj->spec_attr->flex_cont.item_place == item_place &&
        obj->spec_attr->flex_cont.track_place == track_place) {
         return;
@@ -79,7 +79,7 @@ void lv_obj_set_flex_place(lv_obj_t * obj, lv_flex_place_t item_place, lv_flex_p
 
 void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
 {
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
 
     if(obj->spec_attr->flex_cont.gap == gap) return;
 
diff --git a/src/lv_core/lv_grid.c b/src/lv_core/lv_grid.c
index 723f761b3..f87c9e2e8 100644
--- a/src/lv_core/lv_grid.c
+++ b/src/lv_core/lv_grid.c
@@ -81,7 +81,7 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->grid = grid;
 
     _lv_grid_full_refresh(obj);
diff --git a/src/lv_core/lv_group.c b/src/lv_core/lv_group.c
index 571ac30ff..f2c07e59d 100644
--- a/src/lv_core/lv_group.c
+++ b/src/lv_core/lv_group.c
@@ -128,7 +128,7 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
         }
     }
 
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->group_p = group;
 
     lv_obj_t ** next = _lv_ll_ins_tail(&group->obj_ll);
diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c
index 850cfeb97..d20ab51df 100644
--- a/src/lv_core/lv_obj.c
+++ b/src/lv_core/lv_obj.c
@@ -219,7 +219,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
         LV_LOG_TRACE("Object create started");
         LV_ASSERT_OBJ(parent, LV_OBJX_NAME);
         if(parent->spec_attr == NULL) {
-            parent->spec_attr = lv_obj_allocate_rare_attr(parent);
+            parent->spec_attr = lv_obj_allocate_spec_attr(parent);
         }
         new_obj = _lv_ll_ins_head(&parent->spec_attr->child_ll);
         LV_ASSERT_MEM(new_obj);
@@ -275,7 +275,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
         new_obj->flags  = copy->flags;
         if(copy->spec_attr) {
-            lv_obj_allocate_rare_attr(new_obj);
+            lv_obj_allocate_spec_attr(new_obj);
             _lv_memcpy_small(new_obj->spec_attr, copy->spec_attr, sizeof(lv_obj_spec_attr_t));
         }
 #if LV_USE_GROUP
@@ -516,7 +516,7 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
     lv_obj_invalidate(obj);
 
     if(parent->spec_attr == NULL) {
-        parent->spec_attr = lv_obj_allocate_rare_attr(parent);
+        parent->spec_attr = lv_obj_allocate_spec_attr(parent);
     }
 
     lv_obj_t * old_par = obj->parent;
@@ -623,13 +623,13 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
 #if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
     objrare_attr->->ext_click_pad.x1 = left;
     objrare_attr->->ext_click_pad.x2 = right;
     objrare_attr->->ext_click_pad.y1 = top;
     objrare_attr->->ext_click_pad.y2 = bottom;
 #elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
 #else
     LV_UNUSED(obj);
@@ -672,7 +672,7 @@ void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir)
         return;
     }
 
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->base_dir = dir;
     lv_signal_send(obj, LV_SIGNAL_BASE_DIR_CHG, NULL);
 
@@ -812,7 +812,7 @@ void lv_obj_clear_state(lv_obj_t * obj, lv_state_t state)
 void lv_obj_set_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
-    if(obj->spec_attr == NULL) obj->spec_attr = lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) obj->spec_attr = lv_obj_allocate_spec_attr(obj);
 
     obj->spec_attr->event_cb = event_cb;
 }
@@ -1024,7 +1024,7 @@ void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size)
  * @return pointer to the allocated ext.
  * If out of memory NULL is returned and the original ext is preserved
  */
-lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
+lv_obj_spec_attr_t * lv_obj_allocate_spec_attr(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
@@ -1478,7 +1478,7 @@ void lv_obj_set_user_data(lv_obj_t * obj, lv_obj_user_data_t data)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
+    if(obj->spec_attr == NULL) lv_obj_allocate_spec_attr(obj);
     _lv_memcpy(&obj->spec_attr->user_data, &data, sizeof(lv_obj_user_data_t));
 }
 #endif
diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h
index ae0e18e54..eaffe01d4 100644
--- a/src/lv_core/lv_obj.h
+++ b/src/lv_core/lv_obj.h
@@ -545,7 +545,7 @@ void lv_obj_set_design_cb(lv_obj_t * obj, lv_design_cb_t design_cb);
  */
 void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size);
 
-lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
+lv_obj_spec_attr_t * lv_obj_allocate_spec_attr(lv_obj_t * obj);
 /*=======================
  * Getter functions
  *======================*/
diff --git a/src/lv_core/lv_obj_draw.c b/src/lv_core/lv_obj_draw.c
index 643ddb983..d1ee9016c 100644
--- a/src/lv_core/lv_obj_draw.c
+++ b/src/lv_core/lv_obj_draw.c
@@ -395,7 +395,7 @@ void _lv_obj_refresh_ext_draw_pad(lv_obj_t * obj)
     /* Allocate spec. attrs. only if the result is not zero.
      * Zero is the default value if the spec. attr. are not defined. */
     else if(s != 0) {
-        lv_obj_allocate_rare_attr(obj);
+        lv_obj_allocate_spec_attr(obj);
         obj->spec_attr->ext_draw_pad = s;
     }
 }
diff --git a/src/lv_core/lv_obj_scroll.c b/src/lv_core/lv_obj_scroll.c
index 9e026f88e..e0838f6a5 100644
--- a/src/lv_core/lv_obj_scroll.c
+++ b/src/lv_core/lv_obj_scroll.c
@@ -46,7 +46,7 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
 
     if(obj->spec_attr->scroll_mode == mode) return;
     obj->spec_attr->scroll_mode = mode;
@@ -55,7 +55,7 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
 
 void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
 {
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
 
     if(dir != obj->spec_attr->scroll_dir) {
         obj->spec_attr->scroll_dir = dir;
@@ -65,13 +65,13 @@ void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
 
 void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_snap_align_t align)
 {
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->snap_align_x = align;
 }
 
 void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_snap_align_t align)
 {
-    lv_obj_allocate_rare_attr(obj);
+    lv_obj_allocate_spec_attr(obj);
     obj->spec_attr->snap_align_y = align;
 }
 
@@ -240,7 +240,7 @@ void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     if(x == 0 && y == 0) return;
 
     if(obj->spec_attr == NULL) {
-        obj->spec_attr = lv_obj_allocate_rare_attr(obj);
+        obj->spec_attr = lv_obj_allocate_spec_attr(obj);
     }
     obj->spec_attr->scroll.x += x;
     obj->spec_attr->scroll.y += y;