minor fixes

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) {
+    if(cont->grid->col_dsc && cont->grid->row_dsc) {
-        calc_explicit_rows(obj, calc_out);
+        calc_explicit_rows(cont, calc_out);
-        calc_explicit_cols(obj, calc_out);
+        calc_explicit_cols(cont, calc_out);
     }
-    else if(obj->grid->col_dsc && !obj->grid->row_dsc) {
+    else if(cont->grid->col_dsc && !cont->grid->row_dsc) {
-        calc_explicit_cols(obj, calc_out);
+        calc_explicit_cols(cont, calc_out);
-        calc_implicit_rows(obj, calc_out);
+        calc_implicit_rows(cont, calc_out);
     }
-    else if(!obj->grid->col_dsc && obj->grid->row_dsc) {
+    else if(!cont->grid->col_dsc && cont->grid->row_dsc) {
-        calc_implicit_cols(obj, calc_out);
+        calc_implicit_cols(cont, calc_out);
-        calc_explicit_rows(obj, 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];
+    bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
-    calc_out->grid_h = calc_out->y[calc_out->row_num - 1] + calc_out->h[calc_out->row_num - 1] - calc_out->y[0];
+    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->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);
+    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->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);
+    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)

src/lv_core/lv_grid.h

@@ -19,8 +19,8 @@ extern "C" {
  *      DEFINES
  *********************/
 
-#define LV_GRID_CENTER              0
+#define LV_GRID_START               0
-#define LV_GRID_START               1
+#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 {

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);

src/lv_core/lv_indev_scroll.c

@@ -356,6 +356,7 @@ 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) {
+        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) {
@@ -377,9 +378,11 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
                 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,10 +402,9 @@ 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++;
+        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) {
@@ -424,10 +426,12 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
                 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;
 }
 

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;

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_CLICK_FOCUSABLE       = (1 << 2),
-    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 3),
+    LV_OBJ_FLAG_SCROLLABLE      = (1 << 3),
-    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 4),
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 4),
-    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 5),
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 5),
-    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 6),
+    LV_OBJ_FLAG_SCROLL_STOP     = (1 << 6),
-    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 7),
+    LV_OBJ_FLAG_SNAPABLE        = (1 << 7),
-    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 8),
+    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 8),
-    LV_OBJ_FLAG_FOCUS_BUBBLE    = (1 << 9),
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 9),
-    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 10),
+    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;