deprecate LV_ASSERT_OBJ.

include/lvgl/core/lv_obj.h

@@ -472,14 +472,27 @@ void lv_objid_builtin_destroy(void);
  **********************/
 
 #if LV_USE_ASSERT_OBJ
-#  define LV_ASSERT_OBJ(obj_p, obj_class)                                                               \
-    do {                                                                                                \
-        LV_ASSERT_MSG(obj_p != NULL, "The object is NULL");                                             \
-        LV_ASSERT_MSG(lv_obj_has_class(obj_p, obj_class) == true, "Incompatible object type.");         \
-        LV_ASSERT_MSG(lv_obj_is_valid(obj_p)  == true, "The object is invalid, deleted or corrupted?"); \
+  /**
+   * @deprecated Use `LV_CHECK_OBJ(obj, cls, return)` instead.
+   *             `LV_ASSERT_OBJ` aborts on failure; `LV_CHECK_OBJ` logs a warning
+   *             and executes the supplied action, which is safer in production.
+   */
+  #define LV_ASSERT_OBJ(obj_p, obj_class)                                                             \
+    do {                                                                                              \
+      LV_DEPRECATED_MACRO_WARN("LV_ASSERT_OBJ is deprecated. Use LV_CHECK_OBJ instead.");             \
+      LV_ASSERT_MSG(obj_p != NULL, "The object is NULL");                                             \
+      LV_ASSERT_MSG(lv_obj_has_class(obj_p, obj_class) == true, "Incompatible object type.");         \
+      LV_ASSERT_MSG(lv_obj_is_valid(obj_p)  == true, "The object is invalid, deleted or corrupted?"); \
     } while(0)
 # else
-#  define LV_ASSERT_OBJ(obj_p, obj_class) LV_ASSERT_NULL(obj_p)
+  /**
+   * @deprecated Use `LV_CHECK_OBJ(obj, return)` instead.
+   */
+  #define LV_ASSERT_OBJ(obj_p, obj_class) \
+    do { \
+      LV_DEPRECATED_MACRO_WARN("LV_ASSERT_OBJ is deprecated. Use LV_CHECK_OBJ instead."); \
+      LV_ASSERT_NULL(obj_p); \
+    } while(0)
 #endif
 
 #if LV_USE_LOG && LV_LOG_TRACE_OBJ_CREATE

src/core/lv_obj.c

@@ -14,6 +14,7 @@
 #include "lv_obj_class_private.h"
 #include "../indev/lv_indev_private.h"
 #include "../display/lv_display_private.h"
+#include "../misc/lv_check_obj.h"
 #include "lv_obj_draw_private.h"
 
 /*********************
@@ -240,7 +241,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent)
 
 void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     if(lv_obj_has_flag(obj, f)) /*Check if all flags are set*/
         return;
 
@@ -279,7 +280,7 @@ void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
 
 void lv_obj_remove_flag(lv_obj_t * obj, lv_obj_flag_t f)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     if(!lv_obj_has_flag_any(obj, f))
         return;
 
@@ -313,7 +314,7 @@ void lv_obj_set_flag(lv_obj_t * obj, lv_obj_flag_t f, bool v)
 
 void lv_obj_add_state(lv_obj_t * obj, lv_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_state_t new_state = obj->state | state;
     if(obj->state != new_state) {
@@ -326,7 +327,7 @@ void lv_obj_add_state(lv_obj_t * obj, lv_state_t state)
 
 void lv_obj_remove_state(lv_obj_t * obj, lv_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_state_t new_state = obj->state & (~state);
     if(obj->state != new_state) {
@@ -345,7 +346,7 @@ void lv_obj_set_state(lv_obj_t * obj, lv_state_t state, bool v)
 
 void lv_obj_set_radio_button(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     obj->radio_button = en;
 }
 
@@ -355,41 +356,41 @@ void lv_obj_set_radio_button(lv_obj_t * obj, bool en)
 
 bool lv_obj_has_flag(const lv_obj_t * obj, lv_obj_flag_t f)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return false);
 
     return (obj->flags & f)  == f;
 }
 
 bool lv_obj_has_flag_any(const lv_obj_t * obj, lv_obj_flag_t f)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return false);
 
     return !!(obj->flags & f);
 }
 
 lv_state_t lv_obj_get_state(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return obj->state;
 }
 
 bool lv_obj_has_state(const lv_obj_t * obj, lv_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return false);
 
     return !!(obj->state & state);
 }
 
 bool lv_obj_is_radio_button(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return false);
     return obj->radio_button;
 }
 
 lv_group_t * lv_obj_get_group(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return NULL);
 
     if(obj->spec_attr) return obj->spec_attr->group_p;
     else return NULL;
@@ -401,7 +402,7 @@ lv_group_t * lv_obj_get_group(const lv_obj_t * obj)
 
 lv_result_t lv_obj_add_child(lv_obj_t * parent, lv_obj_t * child)
 {
-    LV_ASSERT_OBJ(parent, MY_CLASS);
+    LV_CHECK_OBJ(parent, return LV_RESULT_INVALID);
 
     uint16_t new_child_cnt = parent->spec_attr->child_cnt + 1;
 
@@ -419,8 +420,8 @@ lv_result_t lv_obj_add_child(lv_obj_t * parent, lv_obj_t * child)
 
 void lv_obj_remove_child(lv_obj_t * parent, lv_obj_t * child)
 {
-    LV_ASSERT_OBJ(parent, MY_CLASS);
-    LV_ASSERT_OBJ(child, MY_CLASS);
+    LV_CHECK_OBJ(parent, return);
+    LV_CHECK_OBJ(child, return);
     for(int32_t i = lv_obj_get_index(child); i < (int32_t)parent->spec_attr->child_cnt - 1; i++) {
         parent->spec_attr->children[i] = parent->spec_attr->children[i + 1];
     }
@@ -442,7 +443,7 @@ void lv_obj_remove_child(lv_obj_t * parent, lv_obj_t * child)
 
 lv_obj_spec_attr_t * lv_obj_allocate_spec_attr(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return NULL);
     if(obj->spec_attr) {
         return obj->spec_attr;
     }
@@ -1110,7 +1111,7 @@ static void update_obj_state(lv_obj_t * obj, lv_state_t new_state)
 {
     if(obj->state == new_state) return;
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_state_t prev_state = obj->state;
 
@@ -1325,7 +1326,7 @@ static lv_point_t lv_obj_get_scroll_end_helper(lv_obj_t * obj)
 
 static lv_result_t lv_obj_set_any(lv_obj_t * obj, lv_prop_id_t id, const lv_property_t * prop)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return LV_RESULT_INVALID);
 
     if(id >= LV_PROPERTY_OBJ_FLAG_START && id <= LV_PROPERTY_OBJ_FLAG_END) {
         lv_obj_flag_t flag = 1L << (id - LV_PROPERTY_OBJ_FLAG_START);
@@ -1350,7 +1351,7 @@ static lv_result_t lv_obj_set_any(lv_obj_t * obj, lv_prop_id_t id, const lv_prop
 
 static lv_result_t lv_obj_get_any(const lv_obj_t * obj, lv_prop_id_t id, lv_property_t * prop)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return LV_RESULT_INVALID);
     if(id >= LV_PROPERTY_OBJ_FLAG_START && id <= LV_PROPERTY_OBJ_FLAG_END) {
         lv_obj_flag_t flag = 1L << (id - LV_PROPERTY_OBJ_FLAG_START);
         prop->id = id;

src/core/lv_obj_class.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_obj_class_private.h"
+#include "../misc/lv_check_obj.h"
 #include "lv_obj_private.h"
 #include "../display/lv_display_private.h"
 
@@ -84,7 +85,7 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
     /*Create a normal object*/
     else {
         LV_TRACE_OBJ_CREATE("creating normal object");
-        LV_ASSERT_OBJ(parent, MY_CLASS);
+        LV_CHECK_OBJ(parent, return NULL);
 
         if(!lv_obj_allocate_spec_attr(parent)) {
             lv_free(obj);

src/core/lv_obj_draw.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_obj_draw_private.h"
+#include "../misc/lv_check_obj.h"
 #include "lv_obj_private.h"
 
 /*********************
@@ -394,7 +395,7 @@ int32_t lv_obj_calculate_ext_draw_size(lv_obj_t * obj, lv_part_t part)
 void lv_obj_refresh_ext_draw_size(lv_obj_t * obj)
 {
     LV_PROFILER_DRAW_BEGIN;
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     int32_t s_old = lv_obj_get_ext_draw_size(obj);
     int32_t s_new = 0;

src/core/lv_obj_event.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "../misc/lv_event_private.h"
+#include "../misc/lv_check_obj.h"
 #include "lv_obj_event_private.h"
 #include "lv_obj_class_private.h"
 #include "lv_obj_private.h"
@@ -49,7 +50,7 @@ lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void *
 {
     if(obj == NULL) return LV_RESULT_OK;
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     lv_event_t e;
     e.current_target = obj;
@@ -100,7 +101,7 @@ lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
 
 lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
     if(!lv_obj_allocate_spec_attr(obj)) {
         return NULL;
     }

src/core/lv_obj_pos.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "../misc/lv_area_private.h"
+#include "../misc/lv_check_obj.h"
 #include "../layouts/lv_layout_private.h"
 #include "lv_obj_event_private.h"
 #include "lv_obj_draw_private.h"
@@ -53,7 +54,7 @@ static bool has_blur(const lv_obj_t * obj);
 
 void lv_obj_set_pos(lv_obj_t * obj, int32_t x, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_set_x(obj, x);
     lv_obj_set_y(obj, y);
@@ -61,7 +62,7 @@ void lv_obj_set_pos(lv_obj_t * obj, int32_t x, int32_t y)
 
 void lv_obj_set_x(lv_obj_t * obj, int32_t x)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_style_res_t res_x;
     lv_style_value_t v_x;
@@ -75,7 +76,7 @@ void lv_obj_set_x(lv_obj_t * obj, int32_t x)
 
 void lv_obj_set_y(lv_obj_t * obj, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_style_res_t res_y;
     lv_style_value_t v_y;
@@ -127,6 +128,9 @@ static int32_t calc_dynamic_width(lv_obj_t * obj, lv_style_prop_t prop, int32_t
 
 int32_t lv_obj_calc_dynamic_width(lv_obj_t * obj, lv_style_prop_t prop)
 {
+    LV_CHECK_ARG(obj != NULL, return 0);
+    LV_CHECK_ARG(prop == LV_STYLE_WIDTH || prop == LV_STYLE_MIN_WIDTH || prop == LV_STYLE_MAX_WIDTH, return 0);
+
     return calc_dynamic_width(obj, prop, NULL);
 }
 
@@ -170,12 +174,15 @@ static int32_t calc_dynamic_height(lv_obj_t * obj, lv_style_prop_t prop, int32_t
 
 int32_t lv_obj_calc_dynamic_height(lv_obj_t * obj, lv_style_prop_t prop)
 {
+    LV_CHECK_ARG(obj != NULL, return 0);
+    LV_CHECK_ARG(prop == LV_STYLE_HEIGHT || prop == LV_STYLE_MIN_HEIGHT || prop == LV_STYLE_MAX_HEIGHT, return 0);
+
     return calc_dynamic_height(obj, prop, NULL);
 }
 
 bool lv_obj_refr_size(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     /*If the width or height is set by a layout do not modify them*/
     if(obj->w_layout && obj->h_layout) return false;
@@ -299,7 +306,7 @@ bool lv_obj_refr_size(lv_obj_t * obj)
 
 void lv_obj_set_size(lv_obj_t * obj, int32_t w, int32_t h)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_set_width(obj, w);
     lv_obj_set_height(obj, h);
@@ -307,7 +314,7 @@ void lv_obj_set_size(lv_obj_t * obj, int32_t w, int32_t h)
 
 void lv_obj_set_width(lv_obj_t * obj, int32_t w)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     lv_style_res_t res_w;
     lv_style_value_t v_w;
 
@@ -320,7 +327,7 @@ void lv_obj_set_width(lv_obj_t * obj, int32_t w)
 
 void lv_obj_set_height(lv_obj_t * obj, int32_t h)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     lv_style_res_t res_h;
     lv_style_value_t v_h;
 
@@ -333,6 +340,8 @@ void lv_obj_set_height(lv_obj_t * obj, int32_t h)
 
 void lv_obj_set_content_width(lv_obj_t * obj, int32_t w)
 {
+    LV_CHECK_OBJ(obj, return);
+
     int32_t left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
     int32_t right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
     lv_obj_set_width(obj, w + left + right);
@@ -340,6 +349,8 @@ void lv_obj_set_content_width(lv_obj_t * obj, int32_t w)
 
 void lv_obj_set_content_height(lv_obj_t * obj, int32_t h)
 {
+    LV_CHECK_OBJ(obj, return);
+
     int32_t top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
     int32_t bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
     lv_obj_set_height(obj, h + top + bottom);
@@ -347,7 +358,7 @@ void lv_obj_set_content_height(lv_obj_t * obj, int32_t h)
 
 void lv_obj_set_layout(lv_obj_t * obj, uint32_t layout)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_set_style_layout(obj, layout, 0);
 
@@ -356,6 +367,8 @@ void lv_obj_set_layout(lv_obj_t * obj, uint32_t layout)
 
 bool lv_obj_is_layout_positioned(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return false);
+
     if(lv_obj_has_flag_any(obj, LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_IGNORE_LAYOUT | LV_OBJ_FLAG_FLOATING)) return false;
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -368,6 +381,8 @@ bool lv_obj_is_layout_positioned(const lv_obj_t * obj)
 
 void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return);
+
     obj->layout_inv = 1;
 
     /*Mark the screen as dirty too to mark that there is something to do on this screen*/
@@ -381,6 +396,8 @@ void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
 
 void lv_obj_update_layout(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(update_layout_mutex) {
         LV_LOG_TRACE("Already running, returning");
         return;
@@ -410,25 +427,27 @@ void lv_obj_set_align(lv_obj_t * obj, lv_align_t align)
 
 void lv_obj_align(lv_obj_t * obj, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
 {
+    LV_CHECK_OBJ(obj, return);
     lv_obj_set_style_align(obj, align, 0);
     lv_obj_set_pos(obj, x_ofs, y_ofs);
 }
 
 void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
+    LV_CHECK_OBJ(base, return);
 
     lv_obj_update_layout(obj);
     if(base == NULL) base = lv_obj_get_parent(obj);
 
-    LV_ASSERT_OBJ(base, MY_CLASS);
+    LV_CHECK_OBJ(base, return);
 
     int32_t x = 0;
     int32_t y = 0;
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
 
-    LV_ASSERT_OBJ(parent, MY_CLASS);
+    LV_CHECK_OBJ(parent, return);
 
     int32_t pleft = lv_obj_get_style_space_left(parent, LV_PART_MAIN);
     int32_t ptop = lv_obj_get_style_space_top(parent, LV_PART_MAIN);
@@ -566,14 +585,15 @@ void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, in
 
 void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * coords)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_ARG(coords != NULL, return);
+    LV_CHECK_OBJ(obj, return);
 
     lv_area_copy(coords, &obj->coords);
 }
 
 int32_t lv_obj_get_x(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t rel_x;
     lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -590,14 +610,14 @@ int32_t lv_obj_get_x(const lv_obj_t * obj)
 
 int32_t lv_obj_get_x2(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return lv_obj_get_x(obj) + lv_obj_get_width(obj);
 }
 
 int32_t lv_obj_get_y(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t rel_y;
     lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -614,38 +634,42 @@ int32_t lv_obj_get_y(const lv_obj_t * obj)
 
 int32_t lv_obj_get_y2(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return lv_obj_get_y(obj) + lv_obj_get_height(obj);
 }
 
 int32_t lv_obj_get_x_aligned(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     return lv_obj_get_style_x(obj, LV_PART_MAIN);
 }
 
 int32_t lv_obj_get_y_aligned(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     return lv_obj_get_style_y(obj, LV_PART_MAIN);
 }
 
 int32_t lv_obj_get_width(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return lv_area_get_width(&obj->coords);
 }
 
 int32_t lv_obj_get_height(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return lv_area_get_height(&obj->coords);
 }
 
 int32_t lv_obj_get_content_width(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
     int32_t right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
@@ -655,7 +679,7 @@ int32_t lv_obj_get_content_width(const lv_obj_t * obj)
 
 int32_t lv_obj_get_content_height(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
     int32_t bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
@@ -665,7 +689,7 @@ int32_t lv_obj_get_content_height(const lv_obj_t * obj)
 
 void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_get_coords(obj, area);
     area->x1 += lv_obj_get_style_space_left(obj, LV_PART_MAIN);
@@ -677,6 +701,8 @@ void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area)
 
 int32_t lv_obj_get_self_width(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     lv_point_t p = {0, LV_COORD_MIN};
     lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
     return p.x;
@@ -684,6 +710,8 @@ int32_t lv_obj_get_self_width(const lv_obj_t * obj)
 
 int32_t lv_obj_get_self_height(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     lv_point_t p = {LV_COORD_MIN, 0};
     lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
     return p.y;
@@ -691,7 +719,7 @@ int32_t lv_obj_get_self_height(const lv_obj_t * obj)
 
 int32_t lv_obj_get_style_clamped_width(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t content_width = -1;
     int32_t w = calc_dynamic_width(obj, LV_STYLE_WIDTH, &content_width);
@@ -711,7 +739,7 @@ int32_t lv_obj_get_style_clamped_width(lv_obj_t * obj)
 
 int32_t lv_obj_get_style_clamped_height(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t content_height = -1;
     int32_t h = calc_dynamic_height(obj, LV_STYLE_HEIGHT, &content_height);
@@ -731,7 +759,7 @@ int32_t lv_obj_get_style_clamped_height(lv_obj_t * obj)
 
 bool lv_obj_is_style_any_width_content(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t w = lv_obj_get_style_width(obj, LV_PART_MAIN);
     int32_t minw = lv_obj_get_style_min_width(obj, LV_PART_MAIN);
@@ -741,7 +769,7 @@ bool lv_obj_is_style_any_width_content(lv_obj_t * obj)
 
 bool lv_obj_is_style_any_height_content(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t h = lv_obj_get_style_height(obj, LV_PART_MAIN);
     int32_t minh = lv_obj_get_style_min_height(obj, LV_PART_MAIN);
@@ -751,7 +779,7 @@ bool lv_obj_is_style_any_height_content(lv_obj_t * obj)
 
 bool lv_obj_is_width_min(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t minw = lv_obj_calc_dynamic_width(obj, LV_STYLE_MIN_WIDTH);
     int32_t w = lv_obj_get_width(obj);
@@ -760,7 +788,7 @@ bool lv_obj_is_width_min(lv_obj_t * obj)
 
 bool lv_obj_is_height_min(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t minh = lv_obj_calc_dynamic_height(obj, LV_STYLE_MIN_HEIGHT);
     int32_t h = lv_obj_get_height(obj);
@@ -769,7 +797,7 @@ bool lv_obj_is_height_min(lv_obj_t * obj)
 
 bool lv_obj_is_width_max(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t maxw = lv_obj_calc_dynamic_width(obj, LV_STYLE_MAX_WIDTH);
     int32_t w = lv_obj_get_width(obj);
@@ -778,7 +806,7 @@ bool lv_obj_is_width_max(lv_obj_t * obj)
 
 bool lv_obj_is_height_max(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t maxh = lv_obj_calc_dynamic_height(obj, LV_STYLE_MAX_HEIGHT);
     int32_t h = lv_obj_get_height(obj);
@@ -787,6 +815,8 @@ bool lv_obj_is_height_max(lv_obj_t * obj)
 
 bool lv_obj_refresh_self_size(lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(!lv_obj_is_style_any_width_content(obj) && !lv_obj_is_style_any_height_content(obj))
         return false;
 
@@ -806,6 +836,8 @@ bool lv_obj_refresh_self_size(lv_obj_t * obj)
 
 void lv_obj_refr_pos(lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(lv_obj_is_layout_positioned(obj)) return;
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -915,6 +947,8 @@ void lv_obj_refr_pos(lv_obj_t * obj)
 
 void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y)
 {
+    LV_CHECK_OBJ(obj, return);
+
     /*Convert x and y to absolute coordinates*/
     lv_obj_t * parent = obj->parent;
 
@@ -984,6 +1018,8 @@ void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y)
 
 void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, bool ignore_floating)
 {
+    LV_CHECK_OBJ(obj, return);
+
     uint32_t i;
     uint32_t child_cnt = lv_obj_get_child_count(obj);
     for(i = 0; i < child_cnt; i++) {
@@ -1000,12 +1036,17 @@ void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, boo
 
 void lv_obj_transform_point(const lv_obj_t * obj, lv_point_t * p, lv_obj_point_transform_flag_t flags)
 {
+    LV_CHECK_OBJ(obj, return);
+    LV_CHECK_ARG(p != NULL, return);
+
     lv_obj_transform_point_array(obj, p, 1, flags);
 }
 
 void lv_obj_transform_point_array(const lv_obj_t * obj, lv_point_t points[], size_t count,
                                   lv_obj_point_transform_flag_t flags)
 {
+    LV_CHECK_OBJ(obj, return);
+    
     if(obj) {
         lv_layer_type_t layer_type = lv_obj_get_layer_type(obj);
         bool do_tranf = layer_type == LV_LAYER_TYPE_TRANSFORM;
@@ -1024,6 +1065,9 @@ void lv_obj_transform_point_array(const lv_obj_t * obj, lv_point_t points[], siz
 
 void lv_obj_get_transformed_area(const lv_obj_t * obj, lv_area_t * area, lv_obj_point_transform_flag_t flags)
 {
+    LV_CHECK_ARG(area != NULL, return);
+    LV_CHECK_OBJ(obj, return);
+
     lv_point_t p[4] = {
         {area->x1, area->y1},
         {area->x1, area->y2 + 1},
@@ -1069,6 +1113,7 @@ static lv_obj_tree_walk_res_t blur_walk_cb(lv_obj_t * obj, void * user_data)
             obj_coords.y1 -= ext_size;
             obj_coords.x2 += ext_size;
             obj_coords.y2 += ext_size;
+
             invalidate_area_core(obj, &obj_coords);
 
             /*No need to check the children as the widget is already invalidated
@@ -1089,7 +1134,8 @@ static lv_obj_tree_walk_res_t blur_walk_cb(lv_obj_t * obj, void * user_data)
 
 lv_result_t lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_ARG(area != NULL, return LV_RESULT_INVALID);
+    LV_CHECK_OBJ(obj, return 0);
 
     lv_display_t * disp   = lv_obj_get_display(obj);
     if(!lv_display_is_invalidation_enabled(disp)) return LV_RESULT_INVALID;
@@ -1103,7 +1149,7 @@ lv_result_t lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
 
 lv_result_t lv_obj_invalidate(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     lv_display_t * disp = lv_obj_get_display(obj);
     if(!lv_display_is_invalidation_enabled(disp)) return LV_RESULT_INVALID;
@@ -1124,6 +1170,9 @@ lv_result_t lv_obj_invalidate(const lv_obj_t * obj)
 
 bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
 {
+    LV_CHECK_ARG(area != NULL, return LV_RESULT_INVALID);
+    LV_CHECK_OBJ(obj, return 0);
+
     if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return false;
 
     /*Invalidate the object only if it belongs to the current or previous or one of the layers'*/
@@ -1176,7 +1225,7 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
 
 bool lv_obj_is_visible(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     lv_area_t obj_coords;
     int32_t ext_size = lv_obj_get_ext_draw_size(obj);
@@ -1191,7 +1240,7 @@ bool lv_obj_is_visible(const lv_obj_t * obj)
 
 void lv_obj_set_ext_click_area(lv_obj_t * obj, int32_t size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
@@ -1201,6 +1250,9 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, int32_t size)
 
 void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area)
 {
+    LV_CHECK_ARG(area != NULL, return);
+    LV_CHECK_OBJ(obj, return);
+
     lv_area_copy(area, &obj->coords);
     if(obj->spec_attr) {
         lv_area_increase(area, obj->spec_attr->ext_click_pad, obj->spec_attr->ext_click_pad);
@@ -1209,6 +1261,9 @@ void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area)
 
 bool lv_obj_hit_test(lv_obj_t * obj, const lv_point_t * point)
 {
+    LV_CHECK_ARG(point != NULL, return false);
+    LV_CHECK_OBJ(obj, return false);
+
     if(!lv_obj_has_flag(obj, LV_OBJ_FLAG_CLICKABLE)) return false;
 
     lv_area_t a;
@@ -1249,7 +1304,7 @@ void lv_obj_center(lv_obj_t * obj)
 void lv_obj_set_transform(lv_obj_t * obj, const lv_matrix_t * matrix)
 {
 #if LV_DRAW_TRANSFORM_USE_MATRIX
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!matrix) {
         lv_obj_reset_transform(obj);
@@ -1287,7 +1342,7 @@ void lv_obj_set_transform(lv_obj_t * obj, const lv_matrix_t * matrix)
 void lv_obj_reset_transform(lv_obj_t * obj)
 {
 #if LV_DRAW_TRANSFORM_USE_MATRIX
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     if(!obj->spec_attr) {
         return;
     }
@@ -1316,7 +1371,7 @@ void lv_obj_reset_transform(lv_obj_t * obj)
 const lv_matrix_t * lv_obj_get_transform(const lv_obj_t * obj)
 {
 #if LV_DRAW_TRANSFORM_USE_MATRIX
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
     if(obj->spec_attr) {
         return obj->spec_attr->matrix;
     }

src/core/lv_obj_scroll.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_obj_scroll_private.h"
+#include "../misc/lv_check_obj.h"
 #include "../misc/lv_anim_private.h"
 #include "lv_obj_private.h"
 #include "../indev/lv_indev_scroll.h"
@@ -58,7 +59,7 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
 
 void lv_obj_set_scrollbar_mode(lv_obj_t * obj, lv_scrollbar_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
@@ -71,6 +72,8 @@ void lv_obj_set_scrollbar_mode(lv_obj_t * obj, lv_scrollbar_mode_t mode)
 
 void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
     }
@@ -82,6 +85,8 @@ void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir)
 
 void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
     }
@@ -90,6 +95,8 @@ void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align)
 
 void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
     }
@@ -102,49 +109,63 @@ void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align)
 
 lv_scrollbar_mode_t lv_obj_get_scrollbar_mode(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr) return (lv_scrollbar_mode_t) obj->spec_attr->scrollbar_mode;
     else return LV_SCROLLBAR_MODE_AUTO;
 }
 
 lv_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr) return (lv_dir_t) obj->spec_attr->scroll_dir;
     else return LV_DIR_ALL;
 }
 
 lv_scroll_snap_t lv_obj_get_scroll_snap_x(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_x;
     else return LV_SCROLL_SNAP_NONE;
 }
 
 lv_scroll_snap_t lv_obj_get_scroll_snap_y(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_y;
     else return LV_SCROLL_SNAP_NONE;
 }
 
 int32_t lv_obj_get_scroll_x(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr == NULL) return 0;
     return -obj->spec_attr->scroll.x;
 }
 
 int32_t lv_obj_get_scroll_y(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr == NULL) return 0;
     return -obj->spec_attr->scroll.y;
 }
 
 int32_t lv_obj_get_scroll_top(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(obj->spec_attr == NULL) return 0;
     return -obj->spec_attr->scroll.y;
 }
 
 int32_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     int32_t child_res = LV_COORD_MIN;
     uint32_t i;
@@ -172,7 +193,7 @@ int32_t lv_obj_get_scroll_bottom(const lv_obj_t * obj)
 
 int32_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     /*Normally can't scroll the object out on the left.
      *So simply use the current scroll position as "left size"*/
@@ -215,7 +236,7 @@ int32_t lv_obj_get_scroll_left(const lv_obj_t * obj)
 
 int32_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     /*With RTL base dir can't scroll to the object out on the right.
      *So simply use the current scroll position as "right size"*/
@@ -252,6 +273,9 @@ int32_t lv_obj_get_scroll_right(const lv_obj_t * obj)
 
 void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end)
 {
+    LV_CHECK_OBJ(obj, return);
+    LV_CHECK_ARG(end != NULL, return);
+
     lv_anim_t * a;
     a = lv_anim_get(obj, scroll_x_anim);
     end->x = a ? -a->end_value : lv_obj_get_scroll_x(obj);
@@ -266,6 +290,8 @@ void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end)
 
 void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(dx == 0 && dy == 0) return;
 
     /*We need to know the final sizes for bound check*/
@@ -314,6 +340,8 @@ void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_en
 
 void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(dx == 0 && dy == 0) return;
     if(anim_en) {
         lv_display_t * d = lv_obj_get_display(obj);
@@ -371,12 +399,16 @@ void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t a
 
 void lv_obj_scroll_to(lv_obj_t * obj, int32_t x, int32_t y, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_obj_scroll_to_x(obj, x, anim_en);
     lv_obj_scroll_to_y(obj, y, anim_en);
 }
 
 void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_anim_delete(obj, scroll_x_anim);
 
     int32_t scroll_x = lv_obj_get_scroll_x(obj);
@@ -387,6 +419,8 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en)
 
 void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_anim_delete(obj, scroll_y_anim);
 
     int32_t scroll_y = lv_obj_get_scroll_y(obj);
@@ -397,6 +431,8 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en)
 
 void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     /*Be sure the screens layout is correct*/
     lv_obj_update_layout(obj);
 
@@ -406,6 +442,8 @@ void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en)
 
 void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     /*Be sure the screens layout is correct*/
     lv_obj_update_layout(obj);
 
@@ -421,6 +459,8 @@ void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
 
 lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     if(x == 0 && y == 0) return LV_RESULT_OK;
 
     if(!lv_obj_allocate_spec_attr(obj)) {
@@ -439,6 +479,8 @@ lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y)
 
 bool lv_obj_is_scrolling(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return 0);
+
     lv_indev_t * indev = lv_indev_get_next(NULL);
     while(indev) {
         if(lv_indev_get_scroll_obj(indev) == obj) return true;
@@ -455,12 +497,16 @@ bool lv_obj_is_scrolling(const lv_obj_t * obj)
 
 void lv_obj_stop_scroll_anim(const lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_anim_delete((lv_obj_t *)obj, scroll_y_anim);
     lv_anim_delete((lv_obj_t *)obj, scroll_x_anim);
 }
 
 void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_obj_update_layout(obj);
     lv_point_t p;
     lv_indev_scroll_get_snap_dist(obj, &p);
@@ -471,6 +517,10 @@ void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en)
 
 void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t * ver_area)
 {
+    LV_CHECK_OBJ(obj, return);
+    LV_CHECK_ARG(hor_area != NULL, return;)
+    LV_CHECK_ARG(ver_area != NULL, return;)
+
     lv_area_set(hor_area, 0, 0, -1, -1);
     lv_area_set(ver_area, 0, 0, -1, -1);
 
@@ -647,6 +697,8 @@ void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t *
 
 void lv_obj_scrollbar_invalidate(lv_obj_t * obj)
 {
+    LV_CHECK_ARG(obj != NULL, return;)
+
     lv_area_t hor_area;
     lv_area_t ver_area;
     lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
@@ -659,6 +711,8 @@ void lv_obj_scrollbar_invalidate(lv_obj_t * obj)
 
 void lv_obj_readjust_scroll(lv_obj_t * obj, lv_anim_enable_t anim_en)
 {
+    LV_CHECK_ARG(obj != NULL, return;)
+
     /*Be sure the bottom side is not remains scrolled in*/
     /*With snapping the content can't be scrolled in*/
     if(lv_obj_get_scroll_snap_y(obj) == LV_SCROLL_SNAP_NONE) {

src/core/lv_obj_style.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_obj_private.h"
+#include "../misc/lv_check_obj.h"
 #include "../misc/lv_anim_private.h"
 #include "lv_obj_style_private.h"
 #include "lv_obj_class_private.h"
@@ -238,7 +239,7 @@ void lv_obj_report_style_change(lv_style_t * style)
 
 void lv_obj_refresh_style(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!style_refr) return;
 
@@ -392,7 +393,7 @@ lv_style_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop,
 
 bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_selector_t selector)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     uint32_t i;
     /*Find the style*/

src/core/lv_obj_tree.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_obj_private.h"
+#include "../misc/lv_check_obj.h"
 #include "lv_obj_class_private.h"
 #include "../indev/lv_indev_private.h"
 #include "../display/lv_display_private.h"
@@ -52,6 +53,8 @@ static lv_obj_t * lv_obj_get_first_not_deleting_child(lv_obj_t * obj);
 
 void lv_obj_delete(lv_obj_t * obj)
 {
+    LV_CHECK_OBJ(obj, return);
+
     if(obj->is_deleting)
         return;
 
@@ -91,7 +94,7 @@ void lv_obj_delete(lv_obj_t * obj)
 void lv_obj_clean(lv_obj_t * obj)
 {
     LV_LOG_TRACE("begin (clean %p)", (void *)obj);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_invalidate(obj);
 
@@ -120,6 +123,8 @@ void lv_obj_clean(lv_obj_t * obj)
 
 void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms)
 {
+    LV_CHECK_OBJ(obj, return);
+
     lv_anim_t a;
     lv_anim_init(&a);
     lv_anim_set_var(&a, obj);
@@ -132,19 +137,21 @@ void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms)
 
 void lv_obj_delete_anim_completed_cb(lv_anim_t * a)
 {
+    LV_CHECK_ARG(a != NULL, return);
+
     lv_obj_delete(a->var);
 }
 
 void lv_obj_delete_async(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
     lv_async_call(lv_obj_delete_async_cb, obj);
 }
 
 void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
-    LV_ASSERT_OBJ(parent, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
+    LV_CHECK_OBJ(parent, return);
 
     if(obj->parent == NULL) {
         LV_LOG_WARN("Can't set the parent of a screen");
@@ -191,7 +198,7 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
 
 void lv_obj_move_to_index(lv_obj_t * obj, int32_t index)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     /* Check parent validity */
     lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -240,8 +247,8 @@ void lv_obj_move_to_index(lv_obj_t * obj, int32_t index)
 
 void lv_obj_swap(lv_obj_t * obj1, lv_obj_t * obj2)
 {
-    LV_ASSERT_OBJ(obj1, MY_CLASS);
-    LV_ASSERT_OBJ(obj2, MY_CLASS);
+    LV_CHECK_OBJ(obj1, return);
+    LV_CHECK_OBJ(obj2, return);
 
     lv_obj_t * parent = lv_obj_get_parent(obj1);
     lv_obj_t * parent2 = lv_obj_get_parent(obj2);
@@ -273,7 +280,7 @@ void lv_obj_swap(lv_obj_t * obj1, lv_obj_t * obj2)
 
 lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     const lv_obj_t * par = obj;
     const lv_obj_t * act_par;
@@ -288,7 +295,7 @@ lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
 
 lv_display_t * lv_obj_get_display(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     const lv_obj_t * scr;
 
@@ -311,14 +318,14 @@ lv_display_t * lv_obj_get_display(const lv_obj_t * obj)
 lv_obj_t * lv_obj_get_parent(const lv_obj_t * obj)
 {
     if(obj == NULL) return NULL;
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     return obj->parent;
 }
 
 lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t idx)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     if(obj->spec_attr == NULL) return NULL;
 
@@ -338,7 +345,8 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t idx)
 
 lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return NULL);
+    LV_CHECK_ARG(class_p != NULL, return NULL);
 
     if(obj->spec_attr == NULL) return NULL;
 
@@ -366,6 +374,9 @@ lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx, const lv_
 
 lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx)
 {
+    LV_CHECK_OBJ(obj, return NULL);
+    LV_CHECK_ARG(obj->parent != NULL, return NULL);
+
     lv_obj_t * parent = lv_obj_get_parent(obj);
     int32_t sibling_idx = (int32_t)lv_obj_get_index(obj) + idx;
     if(sibling_idx < 0) return NULL;
@@ -375,7 +386,9 @@ lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx)
 
 lv_obj_t * lv_obj_get_sibling_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return NULL);
+    LV_CHECK_ARG(obj->parent != NULL, return NULL);
+    LV_CHECK_ARG(class_p != NULL, return NULL);
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
     int32_t sibling_idx = (int32_t)lv_obj_get_index_by_type(obj, class_p) + idx;
@@ -386,14 +399,14 @@ lv_obj_t * lv_obj_get_sibling_by_type(const lv_obj_t * obj, int32_t idx, const l
 
 uint32_t lv_obj_get_child_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
     if(obj->spec_attr == NULL) return 0;
     return obj->spec_attr->child_cnt;
 }
 
 uint32_t lv_obj_get_child_count_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
     if(obj->spec_attr == NULL) return 0;
 
     uint32_t i;
@@ -408,7 +421,7 @@ uint32_t lv_obj_get_child_count_by_type(const lv_obj_t * obj, const lv_obj_class
 
 void lv_obj_set_name(lv_obj_t * obj, const char * name)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
@@ -428,7 +441,7 @@ void lv_obj_set_name(lv_obj_t * obj, const char * name)
 
 void lv_obj_set_name_static(lv_obj_t * obj, const char * name)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     if(!lv_obj_allocate_spec_attr(obj)) {
         return;
@@ -441,7 +454,7 @@ void lv_obj_set_name_static(lv_obj_t * obj, const char * name)
 
 const char * lv_obj_get_name(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     if(obj->spec_attr == NULL) return NULL;
     else return obj->spec_attr->name;
@@ -449,7 +462,7 @@ const char * lv_obj_get_name(const lv_obj_t * obj)
 
 void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     const char * name = lv_obj_get_name(obj);
     /*Use a default name which auto-indexing*/
@@ -515,7 +528,7 @@ void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size)
 
 lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * path)
 {
-    LV_ASSERT_OBJ(parent, MY_CLASS);
+    LV_CHECK_OBJ(parent, return 0);
 
     if(parent == NULL || parent->spec_attr == NULL || path == NULL) return NULL;
 
@@ -547,6 +560,8 @@ lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * path)
 
 lv_obj_t * lv_obj_find_by_name(const lv_obj_t * parent, const char * name)
 {
+    LV_CHECK_ARG(name != NULL, return NULL);
+
     if(parent == NULL) parent = lv_display_get_screen_active(NULL);
     if(parent == NULL) return NULL;
 
@@ -569,7 +584,7 @@ lv_obj_t * lv_obj_find_by_name(const lv_obj_t * parent, const char * name)
 
 int32_t lv_obj_get_index(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent == NULL) return -1;
@@ -586,7 +601,8 @@ int32_t lv_obj_get_index(const lv_obj_t * obj)
 
 int32_t lv_obj_get_index_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
+    LV_CHECK_ARG(class_p != NULL, return 0);
 
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent == NULL) return 0xFFFFFFFF;
@@ -633,7 +649,7 @@ void lv_obj_dump_tree(lv_obj_t * start_obj)
 
 static void lv_obj_delete_async_cb(void * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return);
 
     lv_obj_delete(obj);
 }
@@ -790,7 +806,7 @@ static void dump_tree_core(lv_obj_t * obj, int32_t depth)
 
 static lv_obj_t * lv_obj_get_first_not_deleting_child(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, return 0);
 
     if(obj->spec_attr == NULL) return NULL;
 

src/libs/barcode/lv_barcode.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "lv_barcode_private.h"
 #include "../../lvgl.h"
 
@@ -63,7 +64,7 @@ lv_obj_t * lv_barcode_create(lv_obj_t * parent)
 
 void lv_barcode_set_dark_color(lv_obj_t * obj, lv_color_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     barcode->dark_color = color;
@@ -71,7 +72,7 @@ void lv_barcode_set_dark_color(lv_obj_t * obj, lv_color_t color)
 
 void lv_barcode_set_light_color(lv_obj_t * obj, lv_color_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     barcode->light_color = color;
@@ -79,7 +80,7 @@ void lv_barcode_set_light_color(lv_obj_t * obj, lv_color_t color)
 
 void lv_barcode_set_scale(lv_obj_t * obj, uint16_t scale)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     if(scale == 0) {
         scale = 1;
@@ -91,7 +92,7 @@ void lv_barcode_set_scale(lv_obj_t * obj, uint16_t scale)
 
 void lv_barcode_set_direction(lv_obj_t * obj, lv_dir_t direction)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     barcode->direction = direction;
@@ -99,7 +100,7 @@ void lv_barcode_set_direction(lv_obj_t * obj, lv_dir_t direction)
 
 void lv_barcode_set_tiled(lv_obj_t * obj, bool tiled)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     barcode->tiled = tiled;
@@ -108,7 +109,7 @@ void lv_barcode_set_tiled(lv_obj_t * obj, bool tiled)
 
 void lv_barcode_set_encoding(lv_obj_t * obj, lv_barcode_encoding_t encoding)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     barcode->encoding = encoding;
@@ -116,7 +117,7 @@ void lv_barcode_set_encoding(lv_obj_t * obj, lv_barcode_encoding_t encoding)
 
 lv_result_t lv_barcode_update(lv_obj_t * obj, const char * data)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return LV_RESULT_INVALID);
     LV_ASSERT_NULL(data);
 
     if(data == NULL || lv_strlen(data) == 0) {
@@ -231,7 +232,9 @@ lv_result_t lv_barcode_update(lv_obj_t * obj, const char * data)
 
 lv_color_t lv_barcode_get_dark_color(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return (lv_color_t) {
+        0
+    });
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     return barcode->dark_color;
@@ -239,7 +242,9 @@ lv_color_t lv_barcode_get_dark_color(lv_obj_t * obj)
 
 lv_color_t lv_barcode_get_light_color(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return (lv_color_t) {
+        0
+    });
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     return barcode->light_color;
@@ -247,7 +252,7 @@ lv_color_t lv_barcode_get_light_color(lv_obj_t * obj)
 
 uint16_t lv_barcode_get_scale(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_barcode_t * barcode = (lv_barcode_t *)obj;
     return barcode->scale;
@@ -255,7 +260,7 @@ uint16_t lv_barcode_get_scale(lv_obj_t * obj)
 
 lv_barcode_encoding_t lv_barcode_get_encoding(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     const lv_barcode_t * barcode = (const lv_barcode_t *)obj;
     return barcode->encoding;

src/libs/ffmpeg/lv_ffmpeg.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_ffmpeg_private.h"
+#include "../../misc/lv_check_obj.h"
 #if LV_USE_FFMPEG != 0
 #include "../../draw/lv_image_decoder_private.h"
 #include "../../draw/lv_draw_buf_private.h"
@@ -168,7 +169,7 @@ lv_obj_t * lv_ffmpeg_player_create(lv_obj_t * parent)
 
 lv_result_t lv_ffmpeg_player_set_src(lv_obj_t * obj, const char * path)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return LV_RESULT_INVALID);
     lv_result_t res = LV_RESULT_INVALID;
 
     lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
@@ -232,7 +233,7 @@ failed:
 
 void lv_ffmpeg_player_set_cmd(lv_obj_t * obj, lv_ffmpeg_player_cmd_t cmd)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
 
     if(!player->ffmpeg_ctx) {
@@ -271,14 +272,14 @@ void lv_ffmpeg_player_set_cmd(lv_obj_t * obj, lv_ffmpeg_player_cmd_t cmd)
 
 void lv_ffmpeg_player_set_auto_restart(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
     player->auto_restart = en;
 }
 
 void lv_ffmpeg_player_set_decoder(lv_obj_t * obj, const char * name)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
     if(player->decoder_name) {
         lv_free((void *)player->decoder_name);

src/libs/gltf/gltf_view/lv_gltf_view.cpp

@@ -9,6 +9,7 @@
 
 #include "lv_gltf_view_internal.h"
 
+#include "../../../misc/lv_check_obj.h"
 #if LV_USE_GLTF
 
 #include "../gltf_data/lv_gltf_data_internal.hpp"
@@ -106,7 +107,7 @@ lv_obj_t * lv_gltf_create(lv_obj_t * parent)
 lv_gltf_model_t * lv_gltf_load_model_from_file(lv_obj_t * obj, const char * path)
 {
     LV_ASSERT_NULL(obj);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     if(!viewer->environment) {
@@ -123,7 +124,7 @@ lv_gltf_model_t * lv_gltf_load_model_from_file(lv_obj_t * obj, const char * path
 lv_gltf_model_t * lv_gltf_load_model_from_bytes(lv_obj_t * obj, const uint8_t * bytes, size_t len)
 {
     LV_ASSERT_NULL(obj);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     if(!viewer->environment) {
@@ -139,7 +140,7 @@ lv_gltf_model_t * lv_gltf_load_model_from_bytes(lv_obj_t * obj, const uint8_t *
 
 lv_result_t lv_gltf_add_model(lv_obj_t * obj, lv_gltf_model_t * model)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(!model) {
         return LV_RESULT_INVALID;
     }
@@ -157,7 +158,7 @@ lv_result_t lv_gltf_add_model(lv_obj_t * obj, lv_gltf_model_t * model)
 
 void lv_gltf_set_environment(lv_obj_t * obj, lv_gltf_environment_t * env)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * gltf = (lv_gltf_t *)obj;
     if(env == NULL) {
         LV_LOG_WARN("Refusing to assign a NULL environment to the glTF object");
@@ -174,14 +175,14 @@ void lv_gltf_set_environment(lv_obj_t * obj, lv_gltf_environment_t * env)
 
 size_t lv_gltf_get_model_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     return lv_array_size(&((lv_gltf_t *)obj)->models);
 }
 
 lv_gltf_model_t * lv_gltf_get_model_by_index(const lv_obj_t * obj, size_t id)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *) obj;
 
     if(id >= lv_array_size(&viewer->models)) {
@@ -200,7 +201,7 @@ lv_gltf_model_t * lv_gltf_get_primary_model(const lv_obj_t * obj)
 
 void lv_gltf_set_yaw(lv_obj_t * obj, float yaw)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.yaw = yaw;
     lv_obj_invalidate(obj);
@@ -208,14 +209,14 @@ void lv_gltf_set_yaw(lv_obj_t * obj, float yaw)
 
 float lv_gltf_get_yaw(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.yaw;
 }
 
 void lv_gltf_set_pitch(lv_obj_t * obj, float pitch)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.pitch = pitch;
     lv_obj_invalidate(obj);
@@ -223,14 +224,14 @@ void lv_gltf_set_pitch(lv_obj_t * obj, float pitch)
 
 float lv_gltf_get_pitch(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.pitch;
 }
 
 void lv_gltf_set_fov(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.fov = value;
     lv_obj_invalidate(obj);
@@ -238,14 +239,14 @@ void lv_gltf_set_fov(lv_obj_t * obj, float value)
 
 float lv_gltf_get_fov(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.fov;
 }
 
 void lv_gltf_set_distance(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.distance = value;
     lv_obj_invalidate(obj);
@@ -253,14 +254,14 @@ void lv_gltf_set_distance(lv_obj_t * obj, float value)
 
 float lv_gltf_get_distance(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.distance;
 }
 
 float lv_gltf_get_world_distance(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     lv_gltf_view_desc_t * view_desc = &viewer->desc;
     if(viewer->models.size == 0) {
@@ -275,7 +276,7 @@ float lv_gltf_get_world_distance(const lv_obj_t * obj)
 
 void lv_gltf_set_animation_speed(lv_obj_t * obj, uint32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_LOG_WARN("Deprecated. lv_gltf_set_animation_speed should now be set on the model directly via `lv_gltf_model_set_animation_speed`. Setting it on the main model as a fallback");
     lv_gltf_model_t * model = lv_gltf_get_primary_model(obj);
     if(!model) {
@@ -286,7 +287,7 @@ void lv_gltf_set_animation_speed(lv_obj_t * obj, uint32_t value)
 
 uint32_t lv_gltf_get_animation_speed(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_LOG_WARN("Deprecated. lv_gltf_get_animation_speed should now be called on the model directly via `lv_gltf_model_get_animation_speed`. Getting the animation speed from the main model as a fallback");
     lv_gltf_model_t * model = lv_gltf_get_primary_model(obj);
     if(!model) {
@@ -297,7 +298,7 @@ uint32_t lv_gltf_get_animation_speed(const lv_obj_t * obj)
 
 void lv_gltf_set_focal_x(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.focal_x = value;
     lv_obj_invalidate(obj);
@@ -305,14 +306,14 @@ void lv_gltf_set_focal_x(lv_obj_t * obj, float value)
 
 float lv_gltf_get_focal_x(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.focal_x;
 }
 
 void lv_gltf_set_focal_y(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.focal_y = value;
     lv_obj_invalidate(obj);
@@ -320,14 +321,14 @@ void lv_gltf_set_focal_y(lv_obj_t * obj, float value)
 
 float lv_gltf_get_focal_y(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.focal_y;
 }
 
 void lv_gltf_set_focal_z(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.focal_z = value;
     lv_obj_invalidate(obj);
@@ -335,14 +336,14 @@ void lv_gltf_set_focal_z(lv_obj_t * obj, float value)
 
 float lv_gltf_get_focal_z(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.focal_z;
 }
 
 void lv_gltf_set_camera(lv_obj_t * obj, uint32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     if(lv_array_is_empty(&viewer->models)) {
@@ -365,7 +366,7 @@ void lv_gltf_set_camera(lv_obj_t * obj, uint32_t value)
 
 uint32_t lv_gltf_get_camera(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     if(lv_array_is_empty(&viewer->models)) {
@@ -381,7 +382,7 @@ uint32_t lv_gltf_get_camera(const lv_obj_t * obj)
 uint32_t lv_gltf_get_camera_count(const lv_obj_t * obj)
 {
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     if(lv_array_is_empty(&viewer->models)) {
@@ -396,7 +397,7 @@ uint32_t lv_gltf_get_camera_count(const lv_obj_t * obj)
 
 void lv_gltf_set_antialiasing_mode(lv_obj_t * obj, lv_gltf_aa_mode_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.aa_mode = value;
     lv_obj_invalidate(obj);
@@ -404,14 +405,14 @@ void lv_gltf_set_antialiasing_mode(lv_obj_t * obj, lv_gltf_aa_mode_t value)
 
 lv_gltf_aa_mode_t lv_gltf_get_antialiasing_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.aa_mode;
 }
 
 void lv_gltf_set_background_mode(lv_obj_t * obj, lv_gltf_bg_mode_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.bg_mode = value;
     lv_obj_invalidate(obj);
@@ -419,14 +420,14 @@ void lv_gltf_set_background_mode(lv_obj_t * obj, lv_gltf_bg_mode_t value)
 
 lv_gltf_bg_mode_t lv_gltf_get_background_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.bg_mode;
 }
 
 void lv_gltf_set_background_blur(lv_obj_t * obj, uint32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     if(value > 100) {
         value = 100;
@@ -437,14 +438,14 @@ void lv_gltf_set_background_blur(lv_obj_t * obj, uint32_t value)
 
 uint32_t lv_gltf_get_background_blur(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.blur_bg * 100;
 }
 
 void lv_gltf_set_env_brightness(lv_obj_t * obj, uint32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.env_pow = value / 100.;
     lv_obj_invalidate(obj);
@@ -452,14 +453,14 @@ void lv_gltf_set_env_brightness(lv_obj_t * obj, uint32_t value)
 
 uint32_t lv_gltf_get_env_brightness(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.env_pow * 100;
 }
 
 void lv_gltf_set_image_exposure(lv_obj_t * obj, float value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     viewer->desc.exposure = value;
     lv_obj_invalidate(obj);
@@ -467,13 +468,13 @@ void lv_gltf_set_image_exposure(lv_obj_t * obj, float value)
 
 float lv_gltf_get_image_exposure(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     return viewer->desc.exposure;
 }
 void lv_gltf_recenter(lv_obj_t * obj, lv_gltf_model_t * model)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     if(model == NULL) {
         LV_ASSERT(lv_array_size(&viewer->models) > 0);
@@ -488,7 +489,7 @@ void lv_gltf_recenter(lv_obj_t * obj, lv_gltf_model_t * model)
 
 lv_3dray_t lv_gltf_get_ray_from_2d_coordinate(lv_obj_t * obj, const lv_point_t * screen_pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     float norm_mouse_x = (float)screen_pos->x / (float)(lv_obj_get_width(obj));
@@ -544,7 +545,7 @@ lv_result_t lv_intersect_ray_with_plane(const lv_3dray_t * ray, const lv_3dplane
 
 lv_3dplane_t lv_gltf_get_current_view_plane(lv_obj_t * obj, float distance)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
     lv_3dplane_t outplane = {{0, 0, 0}, {0, 0, 0}};
 
@@ -562,7 +563,7 @@ lv_3dplane_t lv_gltf_get_current_view_plane(lv_obj_t * obj, float distance)
 
 lv_result_t lv_gltf_world_to_screen(lv_obj_t * obj, const lv_3dpoint_t world_pos, lv_point_t * screen_pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gltf_t * viewer = (lv_gltf_t *)obj;
 
     fastgltf::math::fvec4 world_position_h = fastgltf::math::fvec4(world_pos.x, world_pos.y, world_pos.z, 1.0f);

src/libs/gstreamer/lv_gstreamer.c

@@ -9,6 +9,7 @@
 
 #include "lv_gstreamer_internal.h"
 
+#include "../../misc/lv_check_obj.h"
 #if LV_USE_GSTREAMER
 
 #include <glib.h>
@@ -102,7 +103,7 @@ lv_obj_t * lv_gstreamer_create(lv_obj_t * parent)
 
 lv_result_t lv_gstreamer_set_src(lv_obj_t * obj, const char * factory_name, const char * property, const char * source)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(factory_name);
 
     if(!obj || !factory_name) {
@@ -198,7 +199,7 @@ lv_result_t lv_gstreamer_set_src(lv_obj_t * obj, const char * factory_name, cons
 
 void lv_gstreamer_play(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(!obj) {
         return;
     }
@@ -217,7 +218,7 @@ void lv_gstreamer_play(lv_obj_t * obj)
 
 void lv_gstreamer_pause(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(!obj) {
         return;
     }
@@ -237,7 +238,7 @@ void lv_gstreamer_pause(lv_obj_t * obj)
 
 void lv_gstreamer_stop(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(!obj) {
         return;
     }
@@ -255,7 +256,7 @@ void lv_gstreamer_stop(lv_obj_t * obj)
 }
 void lv_gstreamer_set_position(lv_obj_t * obj, uint32_t position)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(!obj) {
         return;
     }
@@ -275,7 +276,7 @@ void lv_gstreamer_set_position(lv_obj_t * obj, uint32_t position)
 
 uint32_t lv_gstreamer_get_duration(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->pipeline) {
@@ -292,7 +293,7 @@ uint32_t lv_gstreamer_get_duration(lv_obj_t * obj)
 
 uint32_t lv_gstreamer_get_position(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->pipeline) {
@@ -309,7 +310,7 @@ uint32_t lv_gstreamer_get_position(lv_obj_t * obj)
 
 lv_gstreamer_state_t lv_gstreamer_get_state(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->pipeline) {
@@ -340,7 +341,7 @@ lv_gstreamer_state_t lv_gstreamer_get_state(lv_obj_t * obj)
 void lv_gstreamer_set_volume(lv_obj_t * obj, uint8_t volume)
 {
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->audio_volume) {
@@ -352,7 +353,7 @@ void lv_gstreamer_set_volume(lv_obj_t * obj, uint8_t volume)
 
 uint8_t lv_gstreamer_get_volume(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->audio_volume) {
@@ -368,7 +369,7 @@ uint8_t lv_gstreamer_get_volume(lv_obj_t * obj)
 void lv_gstreamer_set_rate(lv_obj_t * obj, uint32_t rate)
 {
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;
 
     if(!streamer->pipeline) {

src/libs/qrcode/lv_qrcode.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "lv_qrcode_private.h"
 
 #if LV_USE_QRCODE
@@ -60,7 +61,7 @@ lv_obj_t * lv_qrcode_create(lv_obj_t * parent)
 
 void lv_qrcode_set_size(lv_obj_t * obj, int32_t size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_draw_buf_t * old_buf = lv_canvas_get_draw_buf(obj);
     lv_draw_buf_t * new_buf = lv_draw_buf_create(size, size, LV_COLOR_FORMAT_I1, LV_STRIDE_AUTO);
@@ -80,21 +81,21 @@ void lv_qrcode_set_size(lv_obj_t * obj, int32_t size)
 
 void lv_qrcode_set_dark_color(lv_obj_t * obj, lv_color_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_qrcode_t * qrcode = (lv_qrcode_t *)obj;
     qrcode->dark_color = color;
 }
 
 void lv_qrcode_set_light_color(lv_obj_t * obj, lv_color_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_qrcode_t * qrcode = (lv_qrcode_t *)obj;
     qrcode->light_color = color;
 }
 
 lv_result_t lv_qrcode_update(lv_obj_t * obj, const void * data, uint32_t data_len)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return LV_RESULT_INVALID);
     lv_qrcode_t * qrcode = (lv_qrcode_t *)obj;
 
     lv_draw_buf_t * draw_buf = lv_canvas_get_draw_buf(obj);

src/misc/lv_types.h

@@ -16,15 +16,15 @@
  * @endcode
  */
 #ifndef LV_DEPRECATED
-#if defined(PYCPARSER)
-    #define LV_DEPRECATED(msg)
-#elif defined(__GNUC__) || defined(__clang__)
-    #define LV_DEPRECATED(msg) __attribute__((deprecated(msg)))
-#elif defined(_MSC_VER)
-    #define LV_DEPRECATED(msg) __declspec(deprecated(msg))
-#else
-    #define LV_DEPRECATED(msg)
-#endif
+    #if defined(PYCPARSER)
+        #define LV_DEPRECATED(msg)
+    #elif defined(__GNUC__) || defined(__clang__)
+        #define LV_DEPRECATED(msg) __attribute__((deprecated(msg)))
+    #elif defined(_MSC_VER)
+        #define LV_DEPRECATED(msg) __declspec(deprecated(msg))
+    #else
+        #define LV_DEPRECATED(msg)
+    #endif
 #endif /* LV_DEPRECATED not defined */
 
 /**
@@ -42,16 +42,16 @@
  * @endcode
  */
 #if defined(PYCPARSER)
-    #define LV_DEPRECATED_MACRO_WARN(msg) ((void)0)
+#define LV_DEPRECATED_MACRO_WARN(msg) ((void)0)
 #elif defined(__GNUC__) || defined(__clang__)
-    #define LV_DEPRECATED_MACRO_WARN(msg) \
-        do { \
-            typedef int __attribute__((deprecated(msg))) __lv_deprecated_t; \
-            __lv_deprecated_t __lv_deprecated_dummy; \
-            (void)__lv_deprecated_dummy; \
-        } while(0)
+#define LV_DEPRECATED_MACRO_WARN(msg) \
+    do { \
+        typedef int __attribute__((deprecated(msg))) __lv_deprecated_t; \
+        __lv_deprecated_t __lv_deprecated_dummy; \
+        (void)__lv_deprecated_dummy; \
+    } while(0)
 #else
-    /* Fallback: no warning, but the macro still compiles */
-    #define LV_DEPRECATED_MACRO_WARN(msg) ((void)0)
+/* Fallback: no warning, but the macro still compiles */
+#define LV_DEPRECATED_MACRO_WARN(msg) ((void)0)
 #endif
 

src/others/file_explorer/lv_file_explorer.c

@@ -91,7 +91,7 @@ lv_obj_t * lv_file_explorer_create(lv_obj_t * parent)
 #if LV_FILE_EXPLORER_QUICK_ACCESS
 void lv_file_explorer_set_quick_access_path(lv_obj_t * obj, lv_file_explorer_dir_t dir, const char * path)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -138,7 +138,7 @@ void lv_file_explorer_set_quick_access_path(lv_obj_t * obj, lv_file_explorer_dir
 
 void lv_file_explorer_set_sort(lv_obj_t * obj, lv_file_explorer_sort_t sort)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -149,7 +149,7 @@ void lv_file_explorer_set_sort(lv_obj_t * obj, lv_file_explorer_sort_t sort)
 
 void lv_file_explorer_show_back_button(lv_obj_t * obj, bool show)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -161,7 +161,7 @@ void lv_file_explorer_show_back_button(lv_obj_t * obj, bool show)
  *====================*/
 const char * lv_file_explorer_get_selected_file_name(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -170,7 +170,7 @@ const char * lv_file_explorer_get_selected_file_name(const lv_obj_t * obj)
 
 const char * lv_file_explorer_get_current_path(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -179,7 +179,7 @@ const char * lv_file_explorer_get_current_path(const lv_obj_t * obj)
 
 lv_obj_t * lv_file_explorer_get_file_table(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -188,7 +188,7 @@ lv_obj_t * lv_file_explorer_get_file_table(lv_obj_t * obj)
 
 lv_obj_t * lv_file_explorer_get_header(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -197,7 +197,7 @@ lv_obj_t * lv_file_explorer_get_header(lv_obj_t * obj)
 
 lv_obj_t * lv_file_explorer_get_path_label(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -207,7 +207,7 @@ lv_obj_t * lv_file_explorer_get_path_label(lv_obj_t * obj)
 #if LV_FILE_EXPLORER_QUICK_ACCESS
 lv_obj_t * lv_file_explorer_get_quick_access_area(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -216,7 +216,7 @@ lv_obj_t * lv_file_explorer_get_quick_access_area(lv_obj_t * obj)
 
 lv_obj_t * lv_file_explorer_get_places_list(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -225,7 +225,7 @@ lv_obj_t * lv_file_explorer_get_places_list(lv_obj_t * obj)
 
 lv_obj_t * lv_file_explorer_get_device_list(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -236,7 +236,7 @@ lv_obj_t * lv_file_explorer_get_device_list(lv_obj_t * obj)
 
 lv_file_explorer_sort_t lv_file_explorer_get_sort(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 
@@ -248,7 +248,7 @@ lv_file_explorer_sort_t lv_file_explorer_get_sort(const lv_obj_t * obj)
  *====================*/
 void lv_file_explorer_open_dir(lv_obj_t * obj, const char * dir)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     show_dir(obj, dir);
 }
@@ -742,7 +742,7 @@ static void exch_table_item(lv_obj_t * tb, int16_t i, int16_t j)
 
 static void file_explorer_sort(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;
 

src/stdlib/builtin/lv_tlsf.c

@@ -2,6 +2,7 @@
 #if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
 
 #include "lv_tlsf_private.h"
+#include "../../misc/lv_assert.h"
 
 #undef  printf
 #define printf LV_LOG_ERROR

src/widgets/3dtexture/lv_3dtexture.c

@@ -8,6 +8,7 @@
  *********************/
 
 #include "lv_3dtexture_private.h"
+#include "../../misc/lv_check_obj.h"
 #if LV_USE_3DTEXTURE
 
 #include "../../core/lv_obj_class_private.h"
@@ -64,7 +65,7 @@ lv_obj_t * lv_3dtexture_create(lv_obj_t * parent)
 
 void lv_3dtexture_set_src(lv_obj_t * obj, lv_3dtexture_id_t id)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_3dtexture_t * tex = (lv_3dtexture_t *)obj;
     tex->id = id;
@@ -72,7 +73,7 @@ void lv_3dtexture_set_src(lv_obj_t * obj, lv_3dtexture_id_t id)
 
 void lv_3dtexture_set_flip(lv_obj_t * obj, bool h_flip, bool v_flip)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_3dtexture_t * tex = (lv_3dtexture_t *)obj;
 

src/widgets/animimage/lv_animimage.c

@@ -105,14 +105,14 @@ void lv_animimg_set_src_reverse(lv_obj_t * obj, const void * dsc[], size_t num)
 
 void lv_animimg_start(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_start(&animimg->anim);
 }
 
 bool lv_animimg_delete(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return lv_anim_delete(animimg, NULL);
 }
@@ -123,7 +123,7 @@ bool lv_animimg_delete(lv_obj_t * obj)
 
 void lv_animimg_set_duration(lv_obj_t * obj, uint32_t duration)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_duration(&animimg->anim, duration);
     lv_anim_set_reverse_delay(&animimg->anim, duration);
@@ -131,35 +131,35 @@ void lv_animimg_set_duration(lv_obj_t * obj, uint32_t duration)
 
 void lv_animimg_set_repeat_count(lv_obj_t * obj, uint32_t count)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_repeat_count(&animimg->anim, count);
 }
 
 void lv_animimg_set_reverse_duration(lv_obj_t * obj, uint32_t duration)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_reverse_duration(&animimg->anim, duration);
 }
 
 void lv_animimg_set_reverse_delay(lv_obj_t * obj, uint32_t duration)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_reverse_delay(&animimg->anim, duration);
 }
 
 void lv_animimg_set_start_cb(lv_obj_t * obj, lv_anim_start_cb_t start_cb)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_start_cb(&animimg->anim, start_cb);
 }
 
 void lv_animimg_set_completed_cb(lv_obj_t * obj, lv_anim_completed_cb_t completed_cb)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_completed_cb(&animimg->anim, completed_cb);
 }
@@ -170,35 +170,35 @@ void lv_animimg_set_completed_cb(lv_obj_t * obj, lv_anim_completed_cb_t complete
 
 const void ** lv_animimg_get_src(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return animimg->dsc;
 }
 
 uint8_t lv_animimg_get_src_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return animimg->pic_count;
 }
 
 uint32_t lv_animimg_get_duration(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return lv_anim_get_time(&animimg->anim);
 }
 
 uint32_t lv_animimg_get_repeat_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return lv_anim_get_repeat_count(&animimg->anim);
 }
 
 lv_anim_t * lv_animimg_get_anim(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     return &animimg->anim;
 }
@@ -242,7 +242,7 @@ static void index_change(lv_obj_t * obj, int32_t idx)
 
 static void lv_animimg_set_src_inner(lv_obj_t * obj, const void * dsc[], size_t num, bool reverse)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     animimg->dsc = dsc;
     animimg->pic_count = num;

src/widgets/arc/lv_arc.c

@@ -15,6 +15,7 @@
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_event_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../core/lv_observer_private.h"
 
 /*********************
@@ -158,7 +159,7 @@ lv_obj_t * lv_arc_create(lv_obj_t * parent)
 
 void lv_arc_set_start_angle(lv_obj_t * obj, lv_value_precise_t start)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     if(start > 360) start -= 360;
@@ -182,7 +183,7 @@ void lv_arc_set_start_angle(lv_obj_t * obj, lv_value_precise_t start)
 
 void lv_arc_set_end_angle(lv_obj_t * obj, lv_value_precise_t end)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
     if(end > 360) end -= 360;
 
@@ -211,7 +212,7 @@ void lv_arc_set_angles(lv_obj_t * obj, lv_value_precise_t start, lv_value_precis
 
 void lv_arc_set_bg_start_angle(lv_obj_t * obj, lv_value_precise_t start)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     if(start > 360) start -= 360;
@@ -233,7 +234,7 @@ void lv_arc_set_bg_start_angle(lv_obj_t * obj, lv_value_precise_t start)
 
 void lv_arc_set_bg_end_angle(lv_obj_t * obj, lv_value_precise_t end)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     if(end > 360) end -= 360;
@@ -261,7 +262,7 @@ void lv_arc_set_bg_angles(lv_obj_t * obj, lv_value_precise_t start, lv_value_pre
 
 void lv_arc_set_rotation(lv_obj_t * obj, int32_t rotation)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     /* ensure the angle is in the range [0, 360) */
@@ -274,7 +275,7 @@ void lv_arc_set_rotation(lv_obj_t * obj, int32_t rotation)
 
 void lv_arc_set_mode(lv_obj_t * obj, lv_arc_mode_t type)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     int32_t val = arc->value;
@@ -303,7 +304,7 @@ void lv_arc_set_mode(lv_obj_t * obj, lv_arc_mode_t type)
 
 void lv_arc_set_value(lv_obj_t * obj, int32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     if(arc->value == value) return;
@@ -320,7 +321,7 @@ void lv_arc_set_value(lv_obj_t * obj, int32_t value)
 
 void lv_arc_set_range(lv_obj_t * obj, int32_t min, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     if(arc->min_value == min && arc->max_value == max) return;
@@ -350,7 +351,7 @@ void lv_arc_set_max_value(lv_obj_t * obj, int32_t max)
 
 void lv_arc_set_change_rate(lv_obj_t * obj, uint32_t rate)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     arc->chg_rate = rate;
@@ -358,7 +359,7 @@ void lv_arc_set_change_rate(lv_obj_t * obj, uint32_t rate)
 
 void lv_arc_set_knob_offset(lv_obj_t * obj, int32_t offset)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     arc->knob_offset = offset;
@@ -370,67 +371,67 @@ void lv_arc_set_knob_offset(lv_obj_t * obj, int32_t offset)
 
 lv_value_precise_t lv_arc_get_angle_start(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->indic_angle_start;
 }
 
 lv_value_precise_t lv_arc_get_angle_end(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->indic_angle_end;
 }
 
 lv_value_precise_t lv_arc_get_bg_angle_start(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->bg_angle_start;
 }
 
 lv_value_precise_t lv_arc_get_bg_angle_end(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->bg_angle_end;
 }
 
 int32_t lv_arc_get_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->value;
 }
 
 int32_t lv_arc_get_min_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->min_value;
 }
 
 int32_t lv_arc_get_max_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->max_value;
 }
 
 lv_arc_mode_t lv_arc_get_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *) obj)->type;
 }
 
 int32_t lv_arc_get_rotation(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *)obj)->rotation;
 }
 
 int32_t lv_arc_get_knob_offset(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *)obj)->knob_offset;
 }
 
 uint32_t lv_arc_get_change_rate(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arc_t *)obj)->chg_rate;
 }
 
@@ -459,7 +460,7 @@ lv_observer_t * lv_arc_bind_value(lv_obj_t * obj, lv_subject_t * subject)
 
 void lv_arc_align_obj_to_angle(const lv_obj_t * obj, lv_obj_t * obj_to_align, int32_t r_offset)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(obj_to_align);
 
     lv_obj_update_layout(obj);
@@ -480,7 +481,7 @@ void lv_arc_align_obj_to_angle(const lv_obj_t * obj, lv_obj_t * obj_to_align, in
 
 void lv_arc_rotate_obj_to_angle(const lv_obj_t * obj, lv_obj_t * obj_to_rotate, int32_t r_offset)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(obj_to_rotate);
 
     lv_obj_update_layout(obj);
@@ -862,7 +863,7 @@ static void lv_arc_draw(lv_event_t * e)
 
 static void inv_arc_area(lv_obj_t * obj, lv_value_precise_t start_angle, lv_value_precise_t end_angle, lv_part_t part)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     /*Skip this complicated invalidation if the arc is not visible*/
     if(lv_obj_is_visible(obj) == false) return;
@@ -986,7 +987,7 @@ static void get_knob_area(lv_obj_t * obj, const lv_point_t * center, int32_t r,
  */
 static void value_update(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     /*If the value is still not set to any value do not update*/
@@ -1069,7 +1070,7 @@ static int32_t knob_get_extra_size(lv_obj_t * obj)
 static bool lv_arc_angle_within_bg_bounds(lv_obj_t * obj, const lv_value_precise_t angle,
                                           const lv_value_precise_t tolerance_deg)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
     lv_value_precise_t bounds_angle = arc->bg_angle_end - arc->bg_angle_start;

src/widgets/arclabel/lv_arclabel.c

@@ -15,6 +15,7 @@
 #include "../../core/lv_obj_event_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../misc/lv_area_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 
 #if LV_USE_FLOAT
@@ -100,7 +101,7 @@ lv_obj_t * lv_arclabel_create(lv_obj_t * parent)
 
 void lv_arclabel_set_text(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arclabel = (lv_arclabel_t *)obj;
 
     /*If text is NULL then just refresh with the current text*/
@@ -136,7 +137,7 @@ void lv_arclabel_set_text(lv_obj_t * obj, const char * text)
 
 void lv_arclabel_set_text_fmt(lv_obj_t * obj, const char * fmt, ...)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(fmt);
 
     lv_arclabel_t * arclabel = (lv_arclabel_t *)obj;
@@ -163,7 +164,7 @@ void lv_arclabel_set_text_fmt(lv_obj_t * obj, const char * fmt, ...)
 
 void lv_arclabel_set_text_static(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arclabel = (lv_arclabel_t *)obj;
 
     if(arclabel->static_txt == 0 && arclabel->text != NULL) {
@@ -181,7 +182,7 @@ void lv_arclabel_set_text_static(lv_obj_t * obj, const char * text)
 
 void lv_arclabel_set_angle_start(lv_obj_t * obj, lv_value_precise_t start)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->angle_start = start;
@@ -190,7 +191,7 @@ void lv_arclabel_set_angle_start(lv_obj_t * obj, lv_value_precise_t start)
 
 void lv_arclabel_set_angle_size(lv_obj_t * obj, lv_value_precise_t size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->angle_size = size;
@@ -199,7 +200,7 @@ void lv_arclabel_set_angle_size(lv_obj_t * obj, lv_value_precise_t size)
 
 void lv_arclabel_set_offset(lv_obj_t * obj, int32_t offset)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->offset = offset;
@@ -208,7 +209,7 @@ void lv_arclabel_set_offset(lv_obj_t * obj, int32_t offset)
 
 void lv_arclabel_set_dir(lv_obj_t * obj, lv_arclabel_dir_t dir)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->dir = dir;
@@ -217,7 +218,7 @@ void lv_arclabel_set_dir(lv_obj_t * obj, lv_arclabel_dir_t dir)
 
 void lv_arclabel_set_recolor(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
     arc->recolor = en;
     lv_obj_invalidate(obj);
@@ -225,7 +226,7 @@ void lv_arclabel_set_recolor(lv_obj_t * obj, bool en)
 
 void lv_arclabel_set_radius(lv_obj_t * obj, uint32_t radius)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->radius = radius;
@@ -234,7 +235,7 @@ void lv_arclabel_set_radius(lv_obj_t * obj, uint32_t radius)
 
 void lv_arclabel_set_center_offset_x(lv_obj_t * obj, uint32_t x)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->center_offset.x = x;
@@ -243,7 +244,7 @@ void lv_arclabel_set_center_offset_x(lv_obj_t * obj, uint32_t x)
 
 void lv_arclabel_set_center_offset_y(lv_obj_t * obj, uint32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->center_offset.y = y;
@@ -252,7 +253,7 @@ void lv_arclabel_set_center_offset_y(lv_obj_t * obj, uint32_t y)
 
 void lv_arclabel_set_text_vertical_align(lv_obj_t * obj, lv_arclabel_text_align_t align)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->text_align_v = align;
@@ -261,7 +262,7 @@ void lv_arclabel_set_text_vertical_align(lv_obj_t * obj, lv_arclabel_text_align_
 
 void lv_arclabel_set_text_horizontal_align(lv_obj_t * obj, lv_arclabel_text_align_t align)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->text_align_h = align;
@@ -270,7 +271,7 @@ void lv_arclabel_set_text_horizontal_align(lv_obj_t * obj, lv_arclabel_text_alig
 
 void lv_arclabel_set_overflow(lv_obj_t * obj, lv_arclabel_overflow_t overflow)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->overflow = overflow;
@@ -279,7 +280,7 @@ void lv_arclabel_set_overflow(lv_obj_t * obj, lv_arclabel_overflow_t overflow)
 
 void lv_arclabel_set_end_overlap(lv_obj_t * obj, bool overlap)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_arclabel_t * arc = (lv_arclabel_t *)obj;
 
     arc->end_overlap = overlap;
@@ -292,74 +293,74 @@ void lv_arclabel_set_end_overlap(lv_obj_t * obj, bool overlap)
 
 lv_value_precise_t lv_arclabel_get_angle_start(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->angle_start;
 }
 
 lv_value_precise_t lv_arclabel_get_angle_size(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_arclabel_t * arclabel = (lv_arclabel_t *)obj;
     return arclabel->angle_size;
 }
 
 lv_arclabel_dir_t lv_arclabel_get_dir(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->dir;
 }
 
 bool lv_arclabel_get_recolor(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     return ((lv_arclabel_t *) obj)->recolor;
 }
 
 uint32_t lv_arclabel_get_radius(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->radius;
 }
 
 uint32_t lv_arclabel_get_center_offset_x(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->center_offset.x;
 }
 
 uint32_t lv_arclabel_get_center_offset_y(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->center_offset.y;
 }
 
 lv_arclabel_text_align_t lv_arclabel_get_text_vertical_align(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->text_align_v;
 }
 
 lv_arclabel_text_align_t lv_arclabel_get_text_horizontal_align(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->text_align_h;
 }
 
 lv_arclabel_overflow_t lv_arclabel_get_overflow(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     return ((lv_arclabel_t *) obj)->overflow;
 }
 
 bool lv_arclabel_get_end_overlap(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     return ((lv_arclabel_t *) obj)->end_overlap;
 }
 
 lv_value_precise_t lv_arclabel_get_text_angle(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     return arclabel_calc_arc_text_total_angle(obj, NULL, NULL, NULL);
 }

src/widgets/bar/lv_bar.c

@@ -14,6 +14,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_anim_private.h"
 #include "../../core/lv_observer_private.h"
 
@@ -139,7 +140,7 @@ lv_obj_t * lv_bar_create(lv_obj_t * parent)
 
 void lv_bar_set_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     if(bar->cur_value == value) return;
@@ -154,7 +155,7 @@ void lv_bar_set_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim)
 
 void lv_bar_set_start_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_bar_t * bar = (lv_bar_t *)obj;
 
@@ -172,7 +173,7 @@ void lv_bar_set_start_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim
 
 void lv_bar_set_range(lv_obj_t * obj, int32_t min, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_bar_t * bar = (lv_bar_t *)obj;
 
@@ -212,7 +213,7 @@ void lv_bar_set_max_value(lv_obj_t * obj, int32_t max)
 
 void lv_bar_set_mode(lv_obj_t * obj, lv_bar_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     bar->mode = mode;
@@ -225,7 +226,7 @@ void lv_bar_set_mode(lv_obj_t * obj, lv_bar_mode_t mode)
 
 void lv_bar_set_orientation(lv_obj_t * obj, lv_bar_orientation_t orientation)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     bar->orientation = orientation;
@@ -238,7 +239,7 @@ void lv_bar_set_orientation(lv_obj_t * obj, lv_bar_orientation_t orientation)
 
 int32_t lv_bar_get_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     return LV_BAR_GET_ANIM_VALUE(bar->cur_value, bar->cur_value_anim);
@@ -246,7 +247,7 @@ int32_t lv_bar_get_value(const lv_obj_t * obj)
 
 int32_t lv_bar_get_start_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     if(bar->mode != LV_BAR_MODE_RANGE) return bar->min_value;
@@ -256,14 +257,14 @@ int32_t lv_bar_get_start_value(const lv_obj_t * obj)
 
 int32_t lv_bar_get_min_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
     return bar->val_reversed ? bar->max_value : bar->min_value;
 }
 
 int32_t lv_bar_get_max_value(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     return bar->val_reversed ? bar->min_value : bar->max_value;
@@ -271,7 +272,7 @@ int32_t lv_bar_get_max_value(const lv_obj_t * obj)
 
 lv_bar_mode_t lv_bar_get_mode(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     return bar->mode;
@@ -279,7 +280,7 @@ lv_bar_mode_t lv_bar_get_mode(lv_obj_t * obj)
 
 lv_bar_orientation_t lv_bar_get_orientation(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     return bar->orientation;
@@ -287,7 +288,7 @@ lv_bar_orientation_t lv_bar_get_orientation(lv_obj_t * obj)
 
 bool lv_bar_is_symmetrical(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     return  bar->mode == LV_BAR_MODE_SYMMETRICAL && bar->min_value < 0 && bar->max_value > 0 &&

src/widgets/buttonmatrix/lv_buttonmatrix.c

@@ -12,6 +12,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 #include "../../misc/lv_text_ap.h"
 
@@ -111,7 +112,7 @@ lv_obj_t * lv_buttonmatrix_create(lv_obj_t * parent)
 
 void lv_buttonmatrix_set_map(lv_obj_t * obj, const char * const map[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     if(map == NULL) return;
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
@@ -127,7 +128,7 @@ void lv_buttonmatrix_set_map(lv_obj_t * obj, const char * const map[])
 
 void lv_buttonmatrix_set_ctrl_map(lv_obj_t * obj, const lv_buttonmatrix_ctrl_t ctrl_map[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     lv_memcpy(btnm->ctrl_bits, ctrl_map, sizeof(lv_buttonmatrix_ctrl_t) * btnm->btn_cnt);
@@ -137,7 +138,7 @@ void lv_buttonmatrix_set_ctrl_map(lv_obj_t * obj, const lv_buttonmatrix_ctrl_t c
 
 void lv_buttonmatrix_set_selected_button(lv_obj_t * obj, uint32_t btn_id)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
 
@@ -150,7 +151,7 @@ void lv_buttonmatrix_set_selected_button(lv_obj_t * obj, uint32_t btn_id)
 
 void lv_buttonmatrix_set_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_buttonmatrix_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
 
@@ -170,7 +171,7 @@ void lv_buttonmatrix_set_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_buttonm
 
 void lv_buttonmatrix_clear_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_buttonmatrix_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
 
@@ -186,7 +187,7 @@ void lv_buttonmatrix_clear_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_butto
 
 void lv_buttonmatrix_set_button_ctrl_all(lv_obj_t * obj, lv_buttonmatrix_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     uint32_t i;
@@ -197,7 +198,7 @@ void lv_buttonmatrix_set_button_ctrl_all(lv_obj_t * obj, lv_buttonmatrix_ctrl_t
 
 void lv_buttonmatrix_clear_button_ctrl_all(lv_obj_t * obj, lv_buttonmatrix_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     uint32_t i;
@@ -208,7 +209,7 @@ void lv_buttonmatrix_clear_button_ctrl_all(lv_obj_t * obj, lv_buttonmatrix_ctrl_
 
 void lv_buttonmatrix_set_button_width(lv_obj_t * obj, uint32_t btn_id, uint32_t width)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     if(btn_id >= btnm->btn_cnt) return;
@@ -220,7 +221,7 @@ void lv_buttonmatrix_set_button_width(lv_obj_t * obj, uint32_t btn_id, uint32_t
 
 void lv_buttonmatrix_set_one_checked(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     btnm->one_check     = en;
@@ -235,7 +236,7 @@ void lv_buttonmatrix_set_one_checked(lv_obj_t * obj, bool en)
 
 const char * const * lv_buttonmatrix_get_map(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     return btnm->map_p;
@@ -243,7 +244,7 @@ const char * const * lv_buttonmatrix_get_map(const lv_obj_t * obj)
 
 uint32_t lv_buttonmatrix_get_selected_button(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     return btnm->btn_id_sel;
@@ -251,7 +252,7 @@ uint32_t lv_buttonmatrix_get_selected_button(const lv_obj_t * obj)
 
 const char * lv_buttonmatrix_get_button_text(const lv_obj_t * obj, uint32_t btn_id)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     if(btn_id == LV_BUTTONMATRIX_BUTTON_NONE) return NULL;
 
@@ -276,7 +277,7 @@ const char * lv_buttonmatrix_get_button_text(const lv_obj_t * obj, uint32_t btn_
 
 bool lv_buttonmatrix_has_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_buttonmatrix_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
     if(btn_id >= btnm->btn_cnt) return false;
@@ -286,7 +287,7 @@ bool lv_buttonmatrix_has_button_ctrl(lv_obj_t * obj, uint32_t btn_id, lv_buttonm
 
 bool lv_buttonmatrix_get_one_checked(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;
 

src/widgets/calendar/lv_calendar.c

@@ -14,6 +14,7 @@
 #include "../../draw/lv_draw_private.h"
 #include "../../core/lv_obj_class_private.h"
 
+#include "../../misc/lv_check_obj.h"
 /*********************
  *      DEFINES
  *********************/
@@ -82,7 +83,7 @@ lv_obj_t * lv_calendar_create(lv_obj_t * parent)
 
 void lv_calendar_set_day_names(lv_obj_t * obj, const char * day_names[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     uint32_t i;
@@ -94,7 +95,7 @@ void lv_calendar_set_day_names(lv_obj_t * obj, const char * day_names[])
 
 void lv_calendar_set_today_date(lv_obj_t * obj, uint32_t year, uint32_t month, uint32_t day)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     if(calendar->today.year == year && calendar->today.month == month
@@ -109,7 +110,7 @@ void lv_calendar_set_today_date(lv_obj_t * obj, uint32_t year, uint32_t month, u
 
 void lv_calendar_set_today_year(lv_obj_t * obj, uint32_t year)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
     lv_calendar_set_today_date(obj, year, calendar->today.month, calendar->today.day);
 
@@ -117,14 +118,14 @@ void lv_calendar_set_today_year(lv_obj_t * obj, uint32_t year)
 
 void lv_calendar_set_today_month(lv_obj_t * obj, uint32_t month)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
     lv_calendar_set_today_date(obj, calendar->today.year, month, calendar->today.day);
 }
 
 void lv_calendar_set_today_day(lv_obj_t * obj, uint32_t day)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
     lv_calendar_set_today_date(obj, calendar->today.year, calendar->today.month, day);
 }
@@ -133,7 +134,7 @@ void lv_calendar_set_highlighted_dates(lv_obj_t * obj, lv_calendar_date_t highli
 {
     LV_ASSERT_NULL(highlighted);
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     calendar->highlighted_dates     = highlighted;
@@ -144,7 +145,7 @@ void lv_calendar_set_highlighted_dates(lv_obj_t * obj, lv_calendar_date_t highli
 
 void lv_calendar_set_month_shown(lv_obj_t * obj, uint32_t year, uint32_t month)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     /*Don't return if the new value is the same, as this function is also
@@ -242,7 +243,7 @@ void lv_calendar_set_month_shown(lv_obj_t * obj, uint32_t year, uint32_t month)
 
 void lv_calendar_set_shown_year(lv_obj_t * obj, uint32_t year)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
     lv_calendar_set_month_shown(obj, year, calendar->showed_date.month);
 
@@ -250,7 +251,7 @@ void lv_calendar_set_shown_year(lv_obj_t * obj, uint32_t year)
 
 void lv_calendar_set_shown_month(lv_obj_t * obj, uint32_t month)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
     lv_calendar_set_month_shown(obj, calendar->showed_date.year, month);
 }
@@ -261,14 +262,14 @@ void lv_calendar_set_shown_month(lv_obj_t * obj, uint32_t month)
 
 lv_obj_t * lv_calendar_get_btnmatrix(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     const lv_calendar_t * calendar = (lv_calendar_t *)obj;
     return calendar->btnm;
 }
 
 const lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     const lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     return &calendar->today;
@@ -276,7 +277,7 @@ const lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * obj)
 
 const lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     const lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     return &calendar->showed_date;
@@ -284,7 +285,7 @@ const lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * obj)
 
 lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     return calendar->highlighted_dates;
@@ -292,7 +293,7 @@ lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * obj)
 
 size_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     return calendar->highlighted_dates_num;
@@ -300,7 +301,7 @@ size_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * obj)
 
 lv_result_t lv_calendar_get_pressed_date(const lv_obj_t * obj, lv_calendar_date_t * date)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return LV_RESULT_INVALID);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
 
     uint32_t d = lv_buttonmatrix_get_selected_button(calendar->btnm);

src/widgets/canvas/lv_canvas.c

@@ -16,6 +16,7 @@
 #if LV_USE_CANVAS
 
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../misc/cache/lv_cache.h"
 /*********************
@@ -67,7 +68,7 @@ lv_obj_t * lv_canvas_create(lv_obj_t * parent)
 
 void lv_canvas_set_buffer(lv_obj_t * obj, void * buf, int32_t w, int32_t h, lv_color_format_t cf)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(buf);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
@@ -86,7 +87,7 @@ void lv_canvas_set_buffer(lv_obj_t * obj, void * buf, int32_t w, int32_t h, lv_c
 
 void lv_canvas_set_draw_buf(lv_obj_t * obj, lv_draw_buf_t * draw_buf)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(draw_buf);
 
     if(!draw_buf->handlers) {
@@ -108,7 +109,7 @@ void lv_canvas_set_draw_buf(lv_obj_t * obj, lv_draw_buf_t * draw_buf)
 
 void lv_canvas_set_px(lv_obj_t * obj, int32_t x, int32_t y, lv_color_t color, lv_opa_t opa)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
     lv_draw_buf_t * draw_buf = canvas->draw_buf;
@@ -185,7 +186,7 @@ void lv_canvas_set_px(lv_obj_t * obj, int32_t x, int32_t y, lv_color_t color, lv
 
 void lv_canvas_set_palette(lv_obj_t * obj, uint8_t index, lv_color32_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
 
@@ -201,7 +202,7 @@ void lv_canvas_set_palette(lv_obj_t * obj, uint8_t index, lv_color32_t color)
 
 lv_draw_buf_t * lv_canvas_get_draw_buf(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
     return canvas->draw_buf;
@@ -209,7 +210,7 @@ lv_draw_buf_t * lv_canvas_get_draw_buf(lv_obj_t * obj)
 
 lv_color32_t lv_canvas_get_px(lv_obj_t * obj, int32_t x, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return (lv_color32_t){0});
 
     lv_color32_t ret = { 0 };
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
@@ -263,7 +264,7 @@ lv_color32_t lv_canvas_get_px(lv_obj_t * obj, int32_t x, int32_t y)
 
 lv_image_dsc_t * lv_canvas_get_image(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
     return (lv_image_dsc_t *)canvas->draw_buf;
@@ -271,7 +272,7 @@ lv_image_dsc_t * lv_canvas_get_image(lv_obj_t * obj)
 
 const void * lv_canvas_get_buf(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
     if(canvas->draw_buf)
@@ -287,7 +288,7 @@ const void * lv_canvas_get_buf(lv_obj_t * obj)
 void lv_canvas_copy_buf(lv_obj_t * obj, const lv_area_t * canvas_area, lv_draw_buf_t * src_buf,
                         const lv_area_t * src_area)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(src_buf);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
@@ -300,7 +301,7 @@ void lv_canvas_copy_buf(lv_obj_t * obj, const lv_area_t * canvas_area, lv_draw_b
 
 void lv_canvas_fill_bg(lv_obj_t * obj, lv_color_t color, lv_opa_t opa)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_canvas_t * canvas = (lv_canvas_t *)obj;
     lv_draw_buf_t * draw_buf = canvas->draw_buf;

src/widgets/chart/lv_chart.c

@@ -18,6 +18,7 @@
 #include "../../core/lv_obj_class_private.h"
 #include "../../core/lv_obj_draw_private.h"
 
+#include "../../misc/lv_check_obj.h"
 /*********************
  *      DEFINES
  *********************/
@@ -115,7 +116,7 @@ lv_obj_t * lv_chart_create(lv_obj_t * parent)
 
 void lv_chart_set_type(lv_obj_t * obj, lv_chart_type_t type)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->type == type) return;
@@ -144,7 +145,7 @@ void lv_chart_set_type(lv_obj_t * obj, lv_chart_type_t type)
 
 void lv_chart_set_point_count(lv_obj_t * obj, uint32_t cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->point_cnt == cnt) return;
@@ -168,7 +169,7 @@ void lv_chart_set_point_count(lv_obj_t * obj, uint32_t cnt)
 
 void lv_chart_set_axis_min_value(lv_obj_t * obj, lv_chart_axis_t axis, int32_t min)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
 
@@ -199,7 +200,7 @@ void lv_chart_set_axis_min_value(lv_obj_t * obj, lv_chart_axis_t axis, int32_t m
 
 void lv_chart_set_axis_max_value(lv_obj_t * obj, lv_chart_axis_t axis, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     switch(axis) {
@@ -229,7 +230,7 @@ void lv_chart_set_axis_max_value(lv_obj_t * obj, lv_chart_axis_t axis, int32_t m
 
 void lv_chart_set_axis_range(lv_obj_t * obj, lv_chart_axis_t axis, int32_t min, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_set_axis_min_value(obj, axis, min);
     lv_chart_set_axis_max_value(obj, axis, max);
@@ -237,7 +238,7 @@ void lv_chart_set_axis_range(lv_obj_t * obj, lv_chart_axis_t axis, int32_t min,
 
 void lv_chart_set_update_mode(lv_obj_t * obj, lv_chart_update_mode_t update_mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->update_mode == update_mode) return;
@@ -248,7 +249,7 @@ void lv_chart_set_update_mode(lv_obj_t * obj, lv_chart_update_mode_t update_mode
 
 void lv_chart_set_div_line_count(lv_obj_t * obj, uint32_t hdiv, uint32_t vdiv)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->hdiv_cnt == hdiv && chart->vdiv_cnt == vdiv) return;
@@ -261,7 +262,7 @@ void lv_chart_set_div_line_count(lv_obj_t * obj, uint32_t hdiv, uint32_t vdiv)
 
 void lv_chart_set_hor_div_line_count(lv_obj_t * obj, uint32_t cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->hdiv_cnt == cnt) return;
@@ -271,7 +272,7 @@ void lv_chart_set_hor_div_line_count(lv_obj_t * obj, uint32_t cnt)
 
 void lv_chart_set_ver_div_line_count(lv_obj_t * obj, uint32_t cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(chart->vdiv_cnt == cnt) return;
@@ -281,7 +282,7 @@ void lv_chart_set_ver_div_line_count(lv_obj_t * obj, uint32_t cnt)
 
 lv_chart_type_t lv_chart_get_type(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     return chart->type;
@@ -289,7 +290,7 @@ lv_chart_type_t lv_chart_get_type(const lv_obj_t * obj)
 
 uint32_t lv_chart_get_point_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     return chart->point_cnt;
@@ -297,7 +298,7 @@ uint32_t lv_chart_get_point_count(const lv_obj_t * obj)
 
 lv_chart_update_mode_t lv_chart_get_update_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     return chart->update_mode;
@@ -305,7 +306,7 @@ lv_chart_update_mode_t lv_chart_get_update_mode(const lv_obj_t * obj)
 
 uint32_t lv_chart_get_hor_div_line_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     return chart->hdiv_cnt;
@@ -313,7 +314,7 @@ uint32_t lv_chart_get_hor_div_line_count(const lv_obj_t * obj)
 
 uint32_t lv_chart_get_ver_div_line_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     return chart->vdiv_cnt;
@@ -331,7 +332,7 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint3
 {
     LV_ASSERT_NULL(obj);
     LV_ASSERT_NULL(ser);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(id >= chart->point_cnt) {
@@ -452,7 +453,7 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint3
 
 void lv_chart_refresh(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_obj_invalidate(obj);
 }
@@ -465,7 +466,7 @@ lv_chart_series_t * lv_chart_add_series(lv_obj_t * obj, lv_color_t color, lv_cha
 {
     LV_LOG_INFO("begin");
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_chart_t * chart    = (lv_chart_t *)obj;
 
@@ -525,7 +526,7 @@ lv_chart_series_t * lv_chart_add_series(lv_obj_t * obj, lv_color_t color, lv_cha
 
 void lv_chart_remove_series(lv_obj_t * obj, lv_chart_series_t * series)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(series);
 
     lv_chart_t * chart    = (lv_chart_t *)obj;
@@ -540,7 +541,7 @@ void lv_chart_remove_series(lv_obj_t * obj, lv_chart_series_t * series)
 
 void lv_chart_hide_series(lv_obj_t * chart, lv_chart_series_t * series, bool hide)
 {
-    LV_ASSERT_OBJ(chart, MY_CLASS);
+    LV_CHECK_OBJ(chart, MY_CLASS, true, return);
     LV_ASSERT_NULL(series);
 
     series->hidden = hide ? 1 : 0;
@@ -549,7 +550,7 @@ void lv_chart_hide_series(lv_obj_t * chart, lv_chart_series_t * series, bool hid
 
 void lv_chart_set_series_color(lv_obj_t * chart, lv_chart_series_t * series, lv_color_t color)
 {
-    LV_ASSERT_OBJ(chart, MY_CLASS);
+    LV_CHECK_OBJ(chart, MY_CLASS, true, return);
     LV_ASSERT_NULL(series);
 
     series->color = color;
@@ -558,7 +559,9 @@ void lv_chart_set_series_color(lv_obj_t * chart, lv_chart_series_t * series, lv_
 
 lv_color_t lv_chart_get_series_color(lv_obj_t * chart, const lv_chart_series_t * series)
 {
-    LV_ASSERT_OBJ(chart, MY_CLASS);
+    LV_CHECK_OBJ(chart, MY_CLASS, true, return (lv_color_t) {
+        0
+    });
     LV_ASSERT_NULL(series);
     LV_UNUSED(chart);
 
@@ -567,7 +570,7 @@ lv_color_t lv_chart_get_series_color(lv_obj_t * chart, const lv_chart_series_t *
 
 void lv_chart_set_x_start_point(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t id)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
@@ -577,7 +580,7 @@ void lv_chart_set_x_start_point(lv_obj_t * obj, lv_chart_series_t * ser, uint32_
 
 lv_chart_series_t * lv_chart_get_series_next(const lv_obj_t * obj, const lv_chart_series_t * ser)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(ser == NULL) return lv_ll_get_head(&chart->series_ll);
@@ -590,7 +593,7 @@ lv_chart_series_t * lv_chart_get_series_next(const lv_obj_t * obj, const lv_char
 
 lv_chart_cursor_t  * lv_chart_add_cursor(lv_obj_t * obj, lv_color_t color, lv_dir_t dir)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     lv_chart_cursor_t * cursor = lv_ll_ins_head(&chart->cursor_ll);
@@ -608,7 +611,7 @@ lv_chart_cursor_t  * lv_chart_add_cursor(lv_obj_t * obj, lv_color_t color, lv_di
 
 void lv_chart_remove_cursor(lv_obj_t * obj, lv_chart_cursor_t * cursor)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(cursor);
 
     lv_chart_t * chart = (lv_chart_t *)obj;
@@ -672,7 +675,7 @@ lv_point_t lv_chart_get_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * curso
 
 void lv_chart_set_all_values(lv_obj_t * obj, lv_chart_series_t * ser, int32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
@@ -687,7 +690,7 @@ void lv_chart_set_all_values(lv_obj_t * obj, lv_chart_series_t * ser, int32_t va
 
 void lv_chart_set_next_value(lv_obj_t * obj, lv_chart_series_t * ser, int32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
@@ -699,7 +702,7 @@ void lv_chart_set_next_value(lv_obj_t * obj, lv_chart_series_t * ser, int32_t va
 
 void lv_chart_set_next_value2(lv_obj_t * obj, lv_chart_series_t * ser, int32_t x_value, int32_t y_value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
@@ -735,7 +738,7 @@ void lv_chart_set_series_values2(lv_obj_t * obj, lv_chart_series_t * ser, const
 
 void lv_chart_set_series_value_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t id, int32_t value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
     lv_chart_t * chart  = (lv_chart_t *)obj;
 
@@ -747,7 +750,7 @@ void lv_chart_set_series_value_by_id(lv_obj_t * obj, lv_chart_series_t * ser, ui
 void lv_chart_set_series_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t id, int32_t x_value,
                                       int32_t y_value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
     lv_chart_t * chart  = (lv_chart_t *)obj;
 
@@ -764,7 +767,7 @@ void lv_chart_set_series_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, u
 
 void lv_chart_set_series_ext_y_array(lv_obj_t * obj, lv_chart_series_t * ser, int32_t array[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     if(!ser->y_ext_buf_assigned && ser->y_points) lv_free(ser->y_points);
@@ -775,7 +778,7 @@ void lv_chart_set_series_ext_y_array(lv_obj_t * obj, lv_chart_series_t * ser, in
 
 void lv_chart_set_series_ext_x_array(lv_obj_t * obj, lv_chart_series_t * ser, int32_t array[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(ser);
 
     if(!ser->x_ext_buf_assigned && ser->x_points) lv_free(ser->x_points);
@@ -787,7 +790,7 @@ void lv_chart_set_series_ext_x_array(lv_obj_t * obj, lv_chart_series_t * ser, in
 int32_t * lv_chart_get_series_y_array(const lv_obj_t * obj, lv_chart_series_t * ser)
 {
     LV_UNUSED(obj);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(ser);
     return ser->y_points;
 }
@@ -795,7 +798,7 @@ int32_t * lv_chart_get_series_y_array(const lv_obj_t * obj, lv_chart_series_t *
 int32_t * lv_chart_get_series_x_array(const lv_obj_t * obj, lv_chart_series_t * ser)
 {
     LV_UNUSED(obj);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(ser);
     return ser->x_points;
 }
@@ -1655,7 +1658,7 @@ static void draw_series_stacked(lv_obj_t * obj, lv_layer_t * layer)
 
 static void draw_cursors(lv_obj_t * obj, lv_layer_t * layer)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(lv_ll_is_empty(&chart->cursor_ll)) return;

src/widgets/dropdown/lv_dropdown.c

@@ -13,6 +13,7 @@
 
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../misc/lv_text_ap.h"
 #include "../../misc/lv_text_private.h"
@@ -157,7 +158,7 @@ lv_obj_t * lv_dropdown_create(lv_obj_t * parent)
 
 void lv_dropdown_set_text(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     if(!dropdown->static_text && dropdown->text && text && lv_strcmp(dropdown->text, text) == 0) {
         return;
@@ -178,7 +179,7 @@ void lv_dropdown_set_text(lv_obj_t * obj, const char * text)
 
 void lv_dropdown_set_text_static(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
     if(dropdown->static_text && dropdown->text && text && lv_strcmp(dropdown->text, text) == 0) {
@@ -195,7 +196,7 @@ void lv_dropdown_set_text_static(lv_obj_t * obj, const char * text)
 
 void lv_dropdown_set_options(lv_obj_t * obj, const char * options)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(options);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
@@ -243,7 +244,7 @@ void lv_dropdown_set_options(lv_obj_t * obj, const char * options)
 
 void lv_dropdown_set_options_static(lv_obj_t * obj, const char * options)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(options);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
@@ -273,7 +274,7 @@ void lv_dropdown_set_options_static(lv_obj_t * obj, const char * options)
 
 void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(option);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
@@ -346,7 +347,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos)
 
 void lv_dropdown_clear_options(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     if(dropdown->options == NULL) return;
 
@@ -364,7 +365,7 @@ void lv_dropdown_clear_options(lv_obj_t * obj)
 
 void lv_dropdown_set_selected(lv_obj_t * obj, uint32_t sel_opt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     if(dropdown->sel_opt_id == sel_opt) return;
@@ -381,7 +382,7 @@ void lv_dropdown_set_selected(lv_obj_t * obj, uint32_t sel_opt)
 
 void lv_dropdown_set_dir(lv_obj_t * obj, lv_dir_t dir)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     if(dropdown->dir == dir) return;
@@ -393,7 +394,7 @@ void lv_dropdown_set_dir(lv_obj_t * obj, lv_dir_t dir)
 
 void lv_dropdown_set_symbol(lv_obj_t * obj, const void * symbol)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     dropdown->symbol = symbol;
@@ -402,7 +403,7 @@ void lv_dropdown_set_symbol(lv_obj_t * obj, const void * symbol)
 
 void lv_dropdown_set_selected_highlight(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     dropdown->selected_highlight = en;
@@ -415,7 +416,7 @@ void lv_dropdown_set_selected_highlight(lv_obj_t * obj, bool en)
 
 lv_obj_t * lv_dropdown_get_list(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
     return dropdown->list;
@@ -423,7 +424,7 @@ lv_obj_t * lv_dropdown_get_list(lv_obj_t * obj)
 
 const char * lv_dropdown_get_text(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
     return dropdown->text;
@@ -431,7 +432,7 @@ const char * lv_dropdown_get_text(lv_obj_t * obj)
 
 const char * lv_dropdown_get_options(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     return dropdown->options == NULL ? "" : dropdown->options;
@@ -439,7 +440,7 @@ const char * lv_dropdown_get_options(const lv_obj_t * obj)
 
 uint32_t lv_dropdown_get_selected(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
@@ -448,7 +449,7 @@ uint32_t lv_dropdown_get_selected(const lv_obj_t * obj)
 
 uint32_t lv_dropdown_get_option_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
@@ -457,7 +458,7 @@ uint32_t lv_dropdown_get_option_count(const lv_obj_t * obj)
 
 void lv_dropdown_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf_size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
@@ -515,21 +516,21 @@ int32_t lv_dropdown_get_option_index(lv_obj_t * obj, const char * option)
 
 const char * lv_dropdown_get_symbol(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     return dropdown->symbol;
 }
 
 bool lv_dropdown_get_selected_highlight(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     return dropdown->selected_highlight;
 }
 
 lv_dir_t lv_dropdown_get_dir(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
     return dropdown->dir;
 }
@@ -540,7 +541,7 @@ lv_dir_t lv_dropdown_get_dir(const lv_obj_t * obj)
 
 void lv_dropdown_open(lv_obj_t * dropdown_obj)
 {
-    LV_ASSERT_OBJ(dropdown_obj, MY_CLASS);
+    LV_CHECK_OBJ(dropdown_obj, MY_CLASS, true, return);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)dropdown_obj;
 
@@ -638,7 +639,7 @@ void lv_dropdown_open(lv_obj_t * dropdown_obj)
 
 void lv_dropdown_close(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_obj_remove_state(obj, LV_STATE_CHECKED);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
@@ -651,7 +652,7 @@ void lv_dropdown_close(lv_obj_t * obj)
 
 bool lv_dropdown_is_open(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
 
     return lv_obj_has_flag(dropdown->list, LV_OBJ_FLAG_HIDDEN) ? false : true;

src/widgets/gif/lv_gif.c

@@ -8,6 +8,7 @@
  *********************/
 #include "../../lv_public_api.h"
 
+#include "../../misc/lv_check_obj.h"
 #if LV_USE_GIF
 #include "../../misc/lv_timer_private.h"
 #include "../../misc/cache/lv_cache.h"
@@ -81,7 +82,7 @@ lv_obj_t * lv_gif_create(lv_obj_t * parent)
 
 void lv_gif_set_color_format(lv_obj_t * obj, lv_color_format_t color_format)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(gifobj->color_format == color_format) {
@@ -110,7 +111,7 @@ void lv_gif_set_color_format(lv_obj_t * obj, lv_color_format_t color_format)
 
 void lv_gif_set_src(lv_obj_t * obj, const void * src)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(gifobj->is_open) {
@@ -124,7 +125,7 @@ void lv_gif_set_src(lv_obj_t * obj, const void * src)
 
 void lv_gif_restart(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {
@@ -145,7 +146,7 @@ void lv_gif_restart(lv_obj_t * obj)
 
 void lv_gif_pause(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     lv_timer_pause(gifobj->timer);
@@ -153,7 +154,7 @@ void lv_gif_pause(lv_obj_t * obj)
 
 void lv_gif_resume(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {
@@ -166,7 +167,7 @@ void lv_gif_resume(lv_obj_t * obj)
 
 bool lv_gif_is_loaded(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     return gifobj->is_open;
@@ -174,7 +175,7 @@ bool lv_gif_is_loaded(lv_obj_t * obj)
 
 int32_t lv_gif_get_loop_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {
@@ -186,7 +187,7 @@ int32_t lv_gif_get_loop_count(lv_obj_t * obj)
 
 void lv_gif_set_loop_count(lv_obj_t * obj, int32_t count)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {
@@ -199,7 +200,7 @@ void lv_gif_set_loop_count(lv_obj_t * obj, int32_t count)
 
 void lv_gif_set_auto_pause_invisible(lv_obj_t * obj, bool auto_pause)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     gifobj->is_auto_pause = auto_pause;
@@ -230,7 +231,7 @@ bool lv_gif_get_size(const char * src, uint16_t * w, uint16_t * h)
 
 int32_t lv_gif_get_frame_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {
@@ -252,7 +253,7 @@ int32_t lv_gif_get_frame_count(lv_obj_t * obj)
 
 int32_t lv_gif_get_current_frame_index(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_gif_t * gifobj = (lv_gif_t *) obj;
 
     if(!gifobj->is_open) {

src/widgets/image/lv_image.c

@@ -146,7 +146,7 @@ lv_obj_t * lv_image_create(lv_obj_t * parent)
 
 void lv_image_set_src(lv_obj_t * obj, const void * src)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_obj_invalidate(obj);
 
@@ -260,7 +260,7 @@ void lv_image_set_src(lv_obj_t * obj, const void * src)
 
 void lv_image_set_offset_x(lv_obj_t * obj, int32_t x)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -270,7 +270,7 @@ void lv_image_set_offset_x(lv_obj_t * obj, int32_t x)
 
 void lv_image_set_offset_y(lv_obj_t * obj, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -280,7 +280,7 @@ void lv_image_set_offset_y(lv_obj_t * obj, int32_t y)
 
 void lv_image_set_rotation(lv_obj_t * obj, int32_t angle)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     if(img->align > _LV_IMAGE_ALIGN_AUTO_TRANSFORM) {
@@ -325,7 +325,7 @@ void lv_image_set_rotation(lv_obj_t * obj, int32_t angle)
 
 void lv_image_set_pivot(lv_obj_t * obj, int32_t x, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     if(img->align > _LV_IMAGE_ALIGN_AUTO_TRANSFORM) {
@@ -368,7 +368,7 @@ void lv_image_set_pivot(lv_obj_t * obj, int32_t x, int32_t y)
 
 void lv_image_set_pivot_x(lv_obj_t * obj, int32_t x)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     lv_image_set_pivot(obj, x, img->pivot.y);
@@ -376,7 +376,7 @@ void lv_image_set_pivot_x(lv_obj_t * obj, int32_t x)
 
 void lv_image_set_pivot_y(lv_obj_t * obj, int32_t y)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     lv_image_set_pivot(obj, img->pivot.x, y);
@@ -384,7 +384,7 @@ void lv_image_set_pivot_y(lv_obj_t * obj, int32_t y)
 
 void lv_image_set_scale(lv_obj_t * obj, uint32_t zoom)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -400,7 +400,7 @@ void lv_image_set_scale(lv_obj_t * obj, uint32_t zoom)
 
 void lv_image_set_scale_x(lv_obj_t * obj, uint32_t zoom)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -416,7 +416,7 @@ void lv_image_set_scale_x(lv_obj_t * obj, uint32_t zoom)
 
 void lv_image_set_scale_y(lv_obj_t * obj, uint32_t zoom)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -432,7 +432,7 @@ void lv_image_set_scale_y(lv_obj_t * obj, uint32_t zoom)
 
 void lv_image_set_blend_mode(lv_obj_t * obj, lv_blend_mode_t blend_mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -446,7 +446,7 @@ void lv_image_set_blend_mode(lv_obj_t * obj, lv_blend_mode_t blend_mode)
 
 void lv_image_set_antialias(lv_obj_t * obj, bool antialias)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     if(antialias == img->antialias) return;
@@ -457,7 +457,7 @@ void lv_image_set_antialias(lv_obj_t * obj, bool antialias)
 
 void lv_image_set_inner_align(lv_obj_t * obj, lv_image_align_t align)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
     if(align == img->align) return;
@@ -476,7 +476,7 @@ void lv_image_set_inner_align(lv_obj_t * obj, lv_image_align_t align)
 
 void lv_image_set_bitmap_map_src(lv_obj_t * obj, const lv_image_dsc_t * src)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_image_t * img = (lv_image_t *)obj;
     img->bitmap_mask_src = src;
     lv_obj_invalidate(obj);
@@ -488,7 +488,7 @@ void lv_image_set_bitmap_map_src(lv_obj_t * obj, const lv_image_dsc_t * src)
 
 const void * lv_image_get_src(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -497,7 +497,7 @@ const void * lv_image_get_src(lv_obj_t * obj)
 
 int32_t lv_image_get_offset_x(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -506,7 +506,7 @@ int32_t lv_image_get_offset_x(lv_obj_t * obj)
 
 int32_t lv_image_get_offset_y(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -515,7 +515,7 @@ int32_t lv_image_get_offset_y(lv_obj_t * obj)
 
 int32_t lv_image_get_rotation(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -524,7 +524,7 @@ int32_t lv_image_get_rotation(lv_obj_t * obj)
 
 void lv_image_get_pivot(lv_obj_t * obj, lv_point_t * pivot)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -534,7 +534,7 @@ void lv_image_get_pivot(lv_obj_t * obj, lv_point_t * pivot)
 
 int32_t lv_image_get_scale(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -543,7 +543,7 @@ int32_t lv_image_get_scale(lv_obj_t * obj)
 
 int32_t lv_image_get_scale_x(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -552,7 +552,7 @@ int32_t lv_image_get_scale_x(lv_obj_t * obj)
 
 int32_t lv_image_get_scale_y(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -561,7 +561,7 @@ int32_t lv_image_get_scale_y(lv_obj_t * obj)
 
 int32_t lv_image_get_src_width(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
     update_align(obj);
@@ -571,7 +571,7 @@ int32_t lv_image_get_src_width(lv_obj_t * obj)
 
 int32_t lv_image_get_src_height(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
     update_align(obj);
@@ -581,7 +581,7 @@ int32_t lv_image_get_src_height(lv_obj_t * obj)
 
 int32_t lv_image_get_transformed_width(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
     update_align(obj);
@@ -597,7 +597,7 @@ int32_t lv_image_get_transformed_width(lv_obj_t * obj)
 
 int32_t lv_image_get_transformed_height(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
     update_align(obj);
@@ -613,7 +613,7 @@ int32_t lv_image_get_transformed_height(lv_obj_t * obj)
 
 lv_blend_mode_t lv_image_get_blend_mode(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -622,7 +622,7 @@ lv_blend_mode_t lv_image_get_blend_mode(lv_obj_t * obj)
 
 bool lv_image_get_antialias(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -631,7 +631,7 @@ bool lv_image_get_antialias(lv_obj_t * obj)
 
 lv_image_align_t lv_image_get_inner_align(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -640,7 +640,7 @@ lv_image_align_t lv_image_get_inner_align(lv_obj_t * obj)
 
 const lv_image_dsc_t * lv_image_get_bitmap_map_src(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_image_t * img = (lv_image_t *)obj;
 
@@ -652,7 +652,7 @@ const lv_image_dsc_t * lv_image_get_bitmap_map_src(lv_obj_t * obj)
 lv_observer_t * lv_image_bind_src(lv_obj_t * obj, lv_subject_t * subject)
 {
     LV_ASSERT_NULL(subject);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     if(subject->type != LV_SUBJECT_TYPE_POINTER) {
         LV_LOG_WARN("Incompatible subject type: %d", subject->type);

src/widgets/imagebutton/lv_imagebutton.c

@@ -73,7 +73,7 @@ lv_obj_t * lv_imagebutton_create(lv_obj_t * parent)
 void lv_imagebutton_set_src(lv_obj_t * obj, lv_imagebutton_state_t state, const void * src_left, const void * src_mid,
                             const void * src_right)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
 
@@ -90,7 +90,7 @@ void lv_imagebutton_set_src(lv_obj_t * obj, lv_imagebutton_state_t state, const
 
 void lv_imagebutton_set_src_left(lv_obj_t * obj, lv_imagebutton_state_t state, const void * src_left)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
     update_src_info(&imagebutton->src_left[state], src_left);
@@ -99,7 +99,7 @@ void lv_imagebutton_set_src_left(lv_obj_t * obj, lv_imagebutton_state_t state, c
 
 void lv_imagebutton_set_src_right(lv_obj_t * obj, lv_imagebutton_state_t state, const void * src_right)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
     update_src_info(&imagebutton->src_right[state], src_right);
@@ -108,7 +108,7 @@ void lv_imagebutton_set_src_right(lv_obj_t * obj, lv_imagebutton_state_t state,
 
 void lv_imagebutton_set_src_mid(lv_obj_t * obj, lv_imagebutton_state_t state, const void * src_mid)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
     update_src_info(&imagebutton->src_mid[state], src_mid);
@@ -117,7 +117,7 @@ void lv_imagebutton_set_src_mid(lv_obj_t * obj, lv_imagebutton_state_t state, co
 
 void lv_imagebutton_set_state(lv_obj_t * obj, lv_imagebutton_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_state_t obj_state = LV_STATE_DEFAULT;
     if(state == LV_IMAGEBUTTON_STATE_PRESSED ||
@@ -141,7 +141,7 @@ void lv_imagebutton_set_state(lv_obj_t * obj, lv_imagebutton_state_t state)
 
 const void * lv_imagebutton_get_src_left(lv_obj_t * obj, lv_imagebutton_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
 
@@ -150,7 +150,7 @@ const void * lv_imagebutton_get_src_left(lv_obj_t * obj, lv_imagebutton_state_t
 
 const void * lv_imagebutton_get_src_middle(lv_obj_t * obj, lv_imagebutton_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
 
     return imagebutton->src_mid[state].img_src;
@@ -158,7 +158,7 @@ const void * lv_imagebutton_get_src_middle(lv_obj_t * obj, lv_imagebutton_state_
 
 const void * lv_imagebutton_get_src_right(lv_obj_t * obj, lv_imagebutton_state_t state)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_imagebutton_t * imagebutton = (lv_imagebutton_t *)obj;
 
     return imagebutton->src_right[state].img_src;
@@ -332,7 +332,7 @@ static lv_imagebutton_state_t suggest_state(lv_obj_t * obj, lv_imagebutton_state
 
 static lv_imagebutton_state_t get_state(const lv_obj_t * imagebutton)
 {
-    LV_ASSERT_OBJ(imagebutton, MY_CLASS);
+    LV_CHECK_OBJ(imagebutton, MY_CLASS, true, return 0);
 
     lv_state_t obj_state = lv_obj_get_state(imagebutton);
 

src/widgets/ime/lv_ime_pinyin.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_ime_pinyin_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../core/lv_obj_class_private.h"
 #if LV_USE_IME_PINYIN != 0
 
@@ -425,10 +426,10 @@ lv_obj_t * lv_ime_pinyin_create(lv_obj_t * parent)
 void lv_ime_pinyin_set_keyboard(lv_obj_t * obj, lv_obj_t * kb)
 {
     if(kb) {
-        LV_ASSERT_OBJ(kb, &lv_keyboard_class);
+        LV_CHECK_OBJ(kb, &lv_keyboard_class, true, return);
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;
 
     pinyin_ime->kb = kb;
@@ -440,17 +441,17 @@ void lv_ime_pinyin_set_keyboard(lv_obj_t * obj, lv_obj_t * kb)
 
 void lv_ime_pinyin_set_dict(lv_obj_t * obj, lv_pinyin_dict_t * dict)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     init_pinyin_dict(obj, dict);
 }
 
 void lv_ime_pinyin_set_mode(lv_obj_t * obj, lv_ime_pinyin_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;
 
-    LV_ASSERT_OBJ(pinyin_ime->kb, &lv_keyboard_class);
+    LV_CHECK_OBJ(pinyin_ime->kb, &lv_keyboard_class, true, return);
 
     pinyin_ime->mode = mode;
 
@@ -470,7 +471,7 @@ void lv_ime_pinyin_set_mode(lv_obj_t * obj, lv_ime_pinyin_mode_t mode)
 
 lv_obj_t * lv_ime_pinyin_get_kb(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;
 
@@ -479,7 +480,7 @@ lv_obj_t * lv_ime_pinyin_get_kb(lv_obj_t * obj)
 
 lv_obj_t * lv_ime_pinyin_get_cand_panel(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;
 
@@ -488,7 +489,7 @@ lv_obj_t * lv_ime_pinyin_get_cand_panel(lv_obj_t * obj)
 
 const lv_pinyin_dict_t * lv_ime_pinyin_get_dict(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;
 

src/widgets/keyboard/lv_keyboard.c

@@ -237,10 +237,10 @@ lv_obj_t * lv_keyboard_create(lv_obj_t * parent)
 void lv_keyboard_set_textarea(lv_obj_t * obj, lv_obj_t * ta)
 {
     if(ta) {
-        LV_ASSERT_OBJ(ta, &lv_textarea_class);
+        LV_CHECK_OBJ(ta, &lv_textarea_class, true, return);
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
 
     /*Hide the cursor of the old Text area if cursor management is enabled*/
@@ -258,7 +258,7 @@ void lv_keyboard_set_textarea(lv_obj_t * obj, lv_obj_t * ta)
 
 void lv_keyboard_set_mode(lv_obj_t * obj, lv_keyboard_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     if(keyboard->mode == mode) return;
 
@@ -281,7 +281,7 @@ void lv_keyboard_set_popovers(lv_obj_t * obj, bool en)
 void lv_keyboard_set_map(lv_obj_t * obj, lv_keyboard_mode_t mode, const char * const map[],
                          const lv_buttonmatrix_ctrl_t ctrl_map[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     kb_map[mode] = map;
     kb_ctrl[mode] = ctrl_map;
     lv_keyboard_update_map(obj);
@@ -293,14 +293,14 @@ void lv_keyboard_set_map(lv_obj_t * obj, lv_keyboard_mode_t mode, const char * c
 
 lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     return keyboard->ta;
 }
 
 lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     return keyboard->mode;
 }
@@ -319,7 +319,7 @@ void lv_keyboard_def_event_cb(lv_event_t * e)
 {
     lv_obj_t * obj = lv_event_get_current_target(e);
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     uint32_t btn_id = lv_buttonmatrix_get_selected_button(obj);
     if(btn_id == LV_BUTTONMATRIX_BUTTON_NONE) return;

src/widgets/label/lv_label.c

@@ -14,6 +14,7 @@
 #include "../../draw/lv_draw_label_private.h"
 #include "../../core/lv_obj_class_private.h"
 #include "../../core/lv_obj_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../misc/lv_bidi_private.h"
 #include "../../misc/lv_text_ap.h"
@@ -123,7 +124,7 @@ lv_obj_t * lv_label_create(lv_obj_t * parent)
 
 void lv_label_set_text(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     remove_translation_tag(obj);
     set_text_internal(obj, text);
 }
@@ -138,7 +139,7 @@ void lv_label_set_text_fmt(lv_obj_t * obj, const char * fmt, ...)
 
 void lv_label_set_text_vfmt(lv_obj_t * obj, const char * fmt, va_list args)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(fmt);
 
     remove_translation_tag(obj);
@@ -165,7 +166,7 @@ void lv_label_set_text_vfmt(lv_obj_t * obj, const char * fmt, va_list args)
 
 void lv_label_set_text_static(lv_obj_t * obj, const char * text)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_label_t * label = (lv_label_t *)obj;
 
     remove_translation_tag(obj);
@@ -185,7 +186,7 @@ void lv_label_set_text_static(lv_obj_t * obj, const char * text)
 #if LV_USE_TRANSLATION
 void lv_label_set_translation_tag(lv_obj_t * obj, const char * tag)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_label_t * label = (lv_label_t *)obj;
     if(!tag || tag[0] == '\0') {
         return;
@@ -206,7 +207,7 @@ void lv_label_set_translation_tag(lv_obj_t * obj, const char * tag)
 
 void lv_label_set_long_mode(lv_obj_t * obj, lv_label_long_mode_t long_mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_label_t * label = (lv_label_t *)obj;
 
@@ -227,7 +228,7 @@ void lv_label_set_long_mode(lv_obj_t * obj, lv_label_long_mode_t long_mode)
 
 void lv_label_set_text_selection_start(lv_obj_t * obj, uint32_t index)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_label_t * label = (lv_label_t *)obj;
@@ -241,7 +242,7 @@ void lv_label_set_text_selection_start(lv_obj_t * obj, uint32_t index)
 
 void lv_label_set_text_selection_end(lv_obj_t * obj, uint32_t index)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_label_t * label = (lv_label_t *)obj;
@@ -255,7 +256,7 @@ void lv_label_set_text_selection_end(lv_obj_t * obj, uint32_t index)
 
 void lv_label_set_recolor(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_label_t * label = (lv_label_t *)obj;
     if(label->recolor == en) return;
@@ -272,21 +273,21 @@ void lv_label_set_recolor(lv_obj_t * obj, bool en)
 
 char * lv_label_get_text(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_label_t * label = (lv_label_t *)obj;
     return label->text;
 }
 
 lv_label_long_mode_t lv_label_get_long_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_label_t * label = (lv_label_t *)obj;
     return label->long_mode;
 }
 
 void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t * pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(pos);
 
     lv_label_t * label = (lv_label_t *)obj;
@@ -404,7 +405,7 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t
 uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in, bool bidi)
 {
     LV_UNUSED(bidi);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     LV_ASSERT_NULL(pos_in);
     lv_label_t * label = (lv_label_t *)obj;
 
@@ -539,7 +540,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in, bool
 
 bool lv_label_is_char_under_pos(const lv_obj_t * obj, lv_point_t * pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     LV_ASSERT_NULL(pos);
 
     lv_area_t txt_coords;
@@ -622,7 +623,7 @@ bool lv_label_is_char_under_pos(const lv_obj_t * obj, lv_point_t * pos)
 
 uint32_t lv_label_get_text_selection_start(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_label_t * label = (lv_label_t *)obj;
@@ -635,7 +636,7 @@ uint32_t lv_label_get_text_selection_start(const lv_obj_t * obj)
 
 uint32_t lv_label_get_text_selection_end(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_label_t * label = (lv_label_t *)obj;
@@ -648,7 +649,7 @@ uint32_t lv_label_get_text_selection_end(const lv_obj_t * obj)
 
 bool lv_label_get_recolor(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_label_t * label = (lv_label_t *)obj;
     return label->recolor == 0 ? false : true;
@@ -694,7 +695,7 @@ lv_observer_t * lv_label_bind_text(lv_obj_t * obj, lv_subject_t * subject, const
 
 void lv_label_ins_text(lv_obj_t * obj, uint32_t pos, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(txt);
 
     lv_label_t * label = (lv_label_t *)obj;
@@ -720,7 +721,7 @@ void lv_label_ins_text(lv_obj_t * obj, uint32_t pos, const char * txt)
 
 void lv_label_cut_text(lv_obj_t * obj, uint32_t pos, uint32_t cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_label_t * label = (lv_label_t *)obj;
 
     /*Cannot append to static text*/

src/widgets/led/lv_led.c

@@ -81,7 +81,7 @@ lv_obj_t * lv_led_create(lv_obj_t * parent)
 
 void lv_led_set_color(lv_obj_t * obj, lv_color_t color)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_led_t * led = (lv_led_t *)obj;
     led->color = color;
@@ -90,7 +90,7 @@ void lv_led_set_color(lv_obj_t * obj, lv_color_t color)
 
 void lv_led_set_brightness(lv_obj_t * obj, uint8_t bright)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_led_t * led = (lv_led_t *)obj;
     if(led->bright == bright) return;
@@ -126,7 +126,7 @@ void lv_led_toggle(lv_obj_t * obj)
 
 uint8_t lv_led_get_brightness(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_led_t * led = (lv_led_t *)obj;
     return led->bright;

src/widgets/line/lv_line.c

@@ -84,7 +84,7 @@ void lv_line_set_points_mutable(lv_obj_t * obj, lv_point_precise_t points[], uin
 
 void lv_line_set_y_invert(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_line_t * line = (lv_line_t *)obj;
     if(line->y_inv == en) return;
@@ -100,7 +100,7 @@ void lv_line_set_y_invert(lv_obj_t * obj, bool en)
 
 const lv_point_precise_t * lv_line_get_points(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_line_t * line = (lv_line_t *)obj;
     return line->point_array.constant;
@@ -108,7 +108,7 @@ const lv_point_precise_t * lv_line_get_points(lv_obj_t * obj)
 
 uint32_t lv_line_get_point_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_line_t * line = (lv_line_t *)obj;
     return line->point_num;
@@ -116,7 +116,7 @@ uint32_t lv_line_get_point_count(lv_obj_t * obj)
 
 bool lv_line_is_point_array_mutable(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_line_t * line = (lv_line_t *)obj;
     return line->point_array_is_mutable;
@@ -124,7 +124,7 @@ bool lv_line_is_point_array_mutable(lv_obj_t * obj)
 
 lv_point_precise_t * lv_line_get_points_mutable(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_line_t * line = (lv_line_t *)obj;
     if(!line->point_array_is_mutable) {
@@ -136,7 +136,7 @@ lv_point_precise_t * lv_line_get_points_mutable(lv_obj_t * obj)
 
 bool lv_line_get_y_invert(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_line_t * line = (lv_line_t *)obj;
 
@@ -166,7 +166,7 @@ static void lv_line_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 
 static void line_set_points(lv_obj_t * obj, const lv_point_precise_t points[], uint32_t point_num, bool mut)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_line_t * line = (lv_line_t *)obj;
     line->point_array.constant = points;

src/widgets/lottie/lv_lottie.c

@@ -162,7 +162,7 @@ void lv_lottie_set_src_file(lv_obj_t * obj, const char * src)
 
 lv_anim_t * lv_lottie_get_anim(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_lottie_t * lottie = (lv_lottie_t *)obj;
     return lottie->anim;
 }

src/widgets/menu/lv_menu.c

@@ -7,6 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_menu_private.h"
+#include "../../misc/lv_check_obj.h"
 
 #if LV_USE_MENU
 
@@ -140,7 +141,7 @@ lv_obj_t * lv_menu_create(lv_obj_t * parent)
 
 lv_obj_t * lv_menu_page_create(lv_obj_t * menu, char const * const title)
 {
-    LV_ASSERT_OBJ(menu, MY_CLASS);
+    LV_CHECK_OBJ(menu, MY_CLASS, true, return NULL);
 
     LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_page_class, menu);
@@ -173,7 +174,7 @@ lv_obj_t * lv_menu_cont_create(lv_obj_t * parent)
 
 lv_obj_t * lv_menu_section_create(lv_obj_t * parent)
 {
-    LV_ASSERT_OBJ(parent, &lv_menu_page_class);
+    LV_CHECK_OBJ(parent, &lv_menu_page_class, true, return NULL);
 
     LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_section_class, parent);
@@ -183,7 +184,7 @@ lv_obj_t * lv_menu_section_create(lv_obj_t * parent)
 
 lv_obj_t * lv_menu_separator_create(lv_obj_t * parent)
 {
-    LV_ASSERT_OBJ(parent, &lv_menu_page_class);
+    LV_CHECK_OBJ(parent, &lv_menu_page_class, true, return NULL);
 
     LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_separator_class, parent);
@@ -193,7 +194,7 @@ lv_obj_t * lv_menu_separator_create(lv_obj_t * parent)
 
 void lv_menu_refr(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     lv_ll_t * history_ll = &(menu->history_ll);
@@ -221,7 +222,7 @@ void lv_menu_refr(lv_obj_t * obj)
 
 void lv_menu_set_page(lv_obj_t * obj, lv_obj_t * page)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 
@@ -301,7 +302,7 @@ void lv_menu_set_page(lv_obj_t * obj, lv_obj_t * page)
 
 void lv_menu_set_sidebar_page(lv_obj_t * obj, lv_obj_t * page)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 
@@ -364,7 +365,7 @@ void lv_menu_set_sidebar_page(lv_obj_t * obj, lv_obj_t * page)
 
 void lv_menu_set_mode_header(lv_obj_t * obj, lv_menu_mode_header_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 
@@ -377,7 +378,7 @@ void lv_menu_set_mode_header(lv_obj_t * obj, lv_menu_mode_header_t mode)
 
 void lv_menu_set_mode_root_back_button(lv_obj_t * obj, lv_menu_mode_root_back_button_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 
@@ -389,7 +390,7 @@ void lv_menu_set_mode_root_back_button(lv_obj_t * obj, lv_menu_mode_root_back_bu
 
 void lv_menu_set_load_page_event(lv_obj_t * menu, lv_obj_t * obj, lv_obj_t * page)
 {
-    LV_ASSERT_OBJ(menu, MY_CLASS);
+    LV_CHECK_OBJ(menu, MY_CLASS, true, return);
 
     lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
     lv_obj_remove_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
@@ -429,7 +430,7 @@ void lv_menu_set_load_page_event(lv_obj_t * menu, lv_obj_t * obj, lv_obj_t * pag
 
 void lv_menu_set_page_title(lv_obj_t * page_obj, char const * const title)
 {
-    LV_ASSERT_OBJ(page_obj, &lv_menu_page_class);
+    LV_CHECK_OBJ(page_obj, &lv_menu_page_class, true, return);
 
     LV_LOG_INFO("begin");
     lv_menu_page_t * page = (lv_menu_page_t *)page_obj;
@@ -456,7 +457,7 @@ void lv_menu_set_page_title(lv_obj_t * page_obj, char const * const title)
 
 void lv_menu_set_page_title_static(lv_obj_t * page_obj, char const * const title)
 {
-    LV_ASSERT_OBJ(page_obj, &lv_menu_page_class);
+    LV_CHECK_OBJ(page_obj, &lv_menu_page_class, true, return);
 
     LV_LOG_INFO("begin");
     lv_menu_page_t * page = (lv_menu_page_t *)page_obj;
@@ -483,7 +484,7 @@ void lv_menu_set_page_title_static(lv_obj_t * page_obj, char const * const title
  *====================*/
 lv_obj_t * lv_menu_get_cur_main_page(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->main_page;
@@ -491,7 +492,7 @@ lv_obj_t * lv_menu_get_cur_main_page(lv_obj_t * obj)
 
 lv_obj_t * lv_menu_get_cur_sidebar_page(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->sidebar_page;
@@ -499,7 +500,7 @@ lv_obj_t * lv_menu_get_cur_sidebar_page(lv_obj_t * obj)
 
 lv_obj_t * lv_menu_get_main_header(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->main_header;
@@ -507,7 +508,7 @@ lv_obj_t * lv_menu_get_main_header(lv_obj_t * obj)
 
 lv_obj_t * lv_menu_get_main_header_back_button(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->main_header_back_btn;
@@ -515,7 +516,7 @@ lv_obj_t * lv_menu_get_main_header_back_button(lv_obj_t * obj)
 
 lv_obj_t * lv_menu_get_sidebar_header(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->sidebar_header;
@@ -523,7 +524,7 @@ lv_obj_t * lv_menu_get_sidebar_header(lv_obj_t * obj)
 
 lv_obj_t * lv_menu_get_sidebar_header_back_button(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->sidebar_header_back_btn;
@@ -531,7 +532,7 @@ lv_obj_t * lv_menu_get_sidebar_header_back_button(lv_obj_t * obj)
 
 bool lv_menu_back_button_is_root(lv_obj_t * menu, lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(menu, MY_CLASS);
+    LV_CHECK_OBJ(menu, MY_CLASS, true, return false);
 
     if(obj == ((lv_menu_t *)menu)->sidebar_header_back_btn) {
         return true;
@@ -546,21 +547,21 @@ bool lv_menu_back_button_is_root(lv_obj_t * menu, lv_obj_t * obj)
 
 lv_menu_mode_header_t lv_menu_get_mode_header(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->mode_header;
 }
 
 lv_menu_mode_root_back_button_t lv_menu_get_mode_root_back_button(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_menu_t * menu = (lv_menu_t *)obj;
     return menu->mode_root_back_btn;
 }
 
 void lv_menu_clear_history(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
     lv_ll_t * history_ll = &(menu->history_ll);
@@ -696,7 +697,7 @@ static void lv_menu_section_constructor(const lv_obj_class_t * class_p, lv_obj_t
 
 static void lv_menu_refr_sidebar_header_mode(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 
@@ -731,7 +732,7 @@ static void lv_menu_refr_sidebar_header_mode(lv_obj_t * obj)
 
 static void lv_menu_refr_main_header_mode(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_menu_t * menu = (lv_menu_t *)obj;
 

src/widgets/msgbox/lv_msgbox.c

@@ -13,6 +13,7 @@
 
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 
 #if LV_USE_LABEL == 0
@@ -251,28 +252,28 @@ lv_obj_t * lv_msgbox_add_close_button(lv_obj_t * obj)
 
 lv_obj_t * lv_msgbox_get_header(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
     return mbox->header;
 }
 
 lv_obj_t * lv_msgbox_get_footer(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
     return mbox->footer;
 }
 
 lv_obj_t * lv_msgbox_get_content(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
     return mbox->content;
 }
 
 lv_obj_t * lv_msgbox_get_title(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
     return mbox->title;
 }

src/widgets/roller/lv_roller.c

@@ -14,6 +14,7 @@
 #include "../../misc/lv_anim_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../indev/lv_indev_scroll.h"
@@ -119,7 +120,7 @@ lv_obj_t * lv_roller_create(lv_obj_t * parent)
 
 void lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(options);
 
     lv_roller_t * roller = (lv_roller_t *)obj;
@@ -181,7 +182,7 @@ void lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_
 
 void lv_roller_set_selected(lv_obj_t * obj, uint32_t sel_opt, lv_anim_enable_t anim)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     /*Set the value even if it's the same as the current value because
      *if moving to the next option with an animation which was just deleted in the PRESS Call the ancestor's event handler
@@ -242,7 +243,7 @@ bool lv_roller_set_selected_str(lv_obj_t * obj, const char * sel_opt, lv_anim_en
 
 void lv_roller_set_visible_row_count(lv_obj_t * obj, uint32_t row_cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
     int32_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
@@ -256,7 +257,7 @@ void lv_roller_set_visible_row_count(lv_obj_t * obj, uint32_t row_cnt)
 
 uint32_t lv_roller_get_selected(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_roller_t * roller = (lv_roller_t *)obj;
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
@@ -270,7 +271,7 @@ uint32_t lv_roller_get_selected(const lv_obj_t * obj)
 
 void lv_roller_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf_size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_roller_t * roller = (lv_roller_t *)obj;
     lv_roller_get_option_str(obj, roller->sel_opt_id, buf, buf_size);
@@ -283,14 +284,14 @@ void lv_roller_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf_s
  */
 const char * lv_roller_get_options(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     return lv_label_get_text(get_label(obj));
 }
 
 uint32_t lv_roller_get_option_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_roller_t * roller = (lv_roller_t *)obj;
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
@@ -322,7 +323,7 @@ lv_observer_t * lv_roller_bind_value(lv_obj_t * obj, lv_subject_t * subject)
 
 lv_result_t lv_roller_get_option_str(const lv_obj_t * obj, uint32_t option, char * buf, uint32_t buf_size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return LV_RESULT_INVALID);
 
     lv_obj_t * label = get_label(obj);
     uint32_t i;

src/widgets/scale/lv_scale.c

@@ -174,7 +174,7 @@ lv_obj_t * lv_scale_create(lv_obj_t * parent)
 
 void lv_scale_set_mode(lv_obj_t * obj, lv_scale_mode_t mode)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->mode = mode;
@@ -184,7 +184,7 @@ void lv_scale_set_mode(lv_obj_t * obj, lv_scale_mode_t mode)
 
 void lv_scale_set_total_tick_count(lv_obj_t * obj, uint32_t total_tick_count)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->total_tick_count = total_tick_count;
@@ -194,7 +194,7 @@ void lv_scale_set_total_tick_count(lv_obj_t * obj, uint32_t total_tick_count)
 
 void lv_scale_set_major_tick_every(lv_obj_t * obj, uint32_t major_tick_every)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->major_tick_every = major_tick_every;
@@ -204,7 +204,7 @@ void lv_scale_set_major_tick_every(lv_obj_t * obj, uint32_t major_tick_every)
 
 void lv_scale_set_label_show(lv_obj_t * obj, bool show_label)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->label_enabled = show_label;
@@ -214,7 +214,7 @@ void lv_scale_set_label_show(lv_obj_t * obj, bool show_label)
 
 void lv_scale_set_range(lv_obj_t * obj, int32_t min, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->range_min = min;
@@ -225,7 +225,7 @@ void lv_scale_set_range(lv_obj_t * obj, int32_t min, int32_t max)
 
 void lv_scale_set_min_value(lv_obj_t * obj, int32_t min)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
     if(scale->range_min == min) return;
     scale->range_min = min;
@@ -235,7 +235,7 @@ void lv_scale_set_min_value(lv_obj_t * obj, int32_t min)
 
 void lv_scale_set_max_value(lv_obj_t * obj, int32_t max)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
     if(scale->range_max == max) return;
     scale->range_max = max;
@@ -245,7 +245,7 @@ void lv_scale_set_max_value(lv_obj_t * obj, int32_t max)
 
 void lv_scale_set_angle_range(lv_obj_t * obj, uint32_t angle_range)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->angle_range = angle_range;
@@ -255,7 +255,7 @@ void lv_scale_set_angle_range(lv_obj_t * obj, uint32_t angle_range)
 
 void lv_scale_set_rotation(lv_obj_t * obj, int32_t rotation)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
     int32_t normalized_angle = rotation;
 
@@ -280,7 +280,7 @@ void lv_scale_set_line_needle_value(lv_obj_t * obj, lv_obj_t * needle_line, int3
     int32_t needle_length_x, needle_length_y;
     lv_point_precise_t * needle_line_points = NULL;
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
     if((scale->mode != LV_SCALE_MODE_ROUND_INNER) &&
        (scale->mode != LV_SCALE_MODE_ROUND_OUTER)) {
@@ -358,7 +358,7 @@ void lv_scale_set_line_needle_value(lv_obj_t * obj, lv_obj_t * needle_line, int3
 void lv_scale_set_image_needle_value(lv_obj_t * obj, lv_obj_t * needle_img, int32_t value)
 {
     int32_t angle;
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
     if((scale->mode != LV_SCALE_MODE_ROUND_INNER) &&
        (scale->mode != LV_SCALE_MODE_ROUND_OUTER)) {
@@ -381,7 +381,7 @@ void lv_scale_set_image_needle_value(lv_obj_t * obj, lv_obj_t * needle_img, int3
 
 void lv_scale_set_text_src(lv_obj_t * obj, const char * txt_src[])
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->txt_src = txt_src;
@@ -398,7 +398,7 @@ void lv_scale_set_text_src(lv_obj_t * obj, const char * txt_src[])
 
 void lv_scale_set_post_draw(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->post_draw = en;
@@ -408,7 +408,7 @@ void lv_scale_set_post_draw(lv_obj_t * obj, bool en)
 
 void lv_scale_set_draw_ticks_on_top(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_scale_t * scale = (lv_scale_t *)obj;
 
     scale->draw_ticks_on_top = en;
@@ -418,7 +418,7 @@ void lv_scale_set_draw_ticks_on_top(lv_obj_t * obj, bool en)
 
 lv_scale_section_t * lv_scale_add_section(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_scale_t * scale = (lv_scale_t *)obj;
     lv_scale_section_t * section = lv_ll_ins_head(&scale->section_ll);
@@ -439,7 +439,7 @@ lv_scale_section_t * lv_scale_add_section(lv_obj_t * obj)
 
 void lv_scale_set_section_range(lv_obj_t * scale, lv_scale_section_t * section, int32_t min, int32_t max)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     lv_scale_set_section_min_value(scale, section, min);
@@ -448,7 +448,7 @@ void lv_scale_set_section_range(lv_obj_t * scale, lv_scale_section_t * section,
 
 void lv_scale_set_section_min_value(lv_obj_t * scale, lv_scale_section_t * section, int32_t min)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     if(section->range_min == min) return;
@@ -458,7 +458,7 @@ void lv_scale_set_section_min_value(lv_obj_t * scale, lv_scale_section_t * secti
 
 void lv_scale_set_section_max_value(lv_obj_t * scale, lv_scale_section_t * section, int32_t max)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     if(section->range_max == max) return;
@@ -477,7 +477,7 @@ void lv_scale_section_set_range(lv_scale_section_t * section, int32_t min, int32
 
 void lv_scale_set_section_style_main(lv_obj_t * scale, lv_scale_section_t * section, const lv_style_t * style)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     section->main_style = style;
@@ -486,7 +486,7 @@ void lv_scale_set_section_style_main(lv_obj_t * scale, lv_scale_section_t * sect
 
 void lv_scale_set_section_style_indicator(lv_obj_t * scale, lv_scale_section_t * section, const lv_style_t * style)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     section->indicator_style = style;
@@ -495,7 +495,7 @@ void lv_scale_set_section_style_indicator(lv_obj_t * scale, lv_scale_section_t *
 
 void lv_scale_set_section_style_items(lv_obj_t * scale, lv_scale_section_t * section, const lv_style_t * style)
 {
-    LV_ASSERT_OBJ(scale, MY_CLASS);
+    LV_CHECK_OBJ(scale, MY_CLASS, true, return);
     LV_ASSERT_NULL(section);
 
     section->items_style = style;
@@ -585,7 +585,7 @@ int32_t lv_scale_get_range_max_value(lv_obj_t * obj)
 lv_observer_t * lv_scale_bind_section_min_value(lv_obj_t * obj, lv_scale_section_t * section, lv_subject_t * subject)
 {
     LV_ASSERT_NULL(subject);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(section);
 
     if(subject->type != LV_SUBJECT_TYPE_INT) {
@@ -601,7 +601,7 @@ lv_observer_t * lv_scale_bind_section_min_value(lv_obj_t * obj, lv_scale_section
 lv_observer_t * lv_scale_bind_section_max_value(lv_obj_t * obj, lv_scale_section_t * section, lv_subject_t * subject)
 {
     LV_ASSERT_NULL(subject);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(section);
 
     if(subject->type != LV_SUBJECT_TYPE_INT) {
@@ -618,7 +618,7 @@ lv_observer_t * lv_scale_bind_line_needle_value(lv_obj_t * obj, lv_obj_t * needl
                                                 lv_subject_t * subject)
 {
     LV_ASSERT_NULL(subject);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(needle_line);
 
     if(subject->type != LV_SUBJECT_TYPE_INT) {
@@ -650,7 +650,7 @@ lv_observer_t * lv_scale_bind_line_needle_value(lv_obj_t * obj, lv_obj_t * needl
 lv_observer_t * lv_scale_bind_image_needle_value(lv_obj_t * obj, lv_obj_t * needle_img, lv_subject_t * subject)
 {
     LV_ASSERT_NULL(subject);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     LV_ASSERT_NULL(needle_img);
 
     if(subject->type != LV_SUBJECT_TYPE_INT) {

src/widgets/slider/lv_slider.c

@@ -14,6 +14,7 @@
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_event_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../indev/lv_indev_private.h"
 #include "../../core/lv_observer_private.h"
 
@@ -128,7 +129,7 @@ lv_obj_t * lv_slider_create(lv_obj_t * parent)
 
 bool lv_slider_is_dragged(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_slider_t * slider = (lv_slider_t *)obj;
 
     return slider->dragging;

src/widgets/span/lv_span.c

@@ -13,6 +13,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 #include "../../misc/lv_bidi_private.h"
 #include "../../core/lv_observer_private.h"
@@ -163,7 +164,7 @@ lv_span_t * lv_spangroup_add_span(lv_obj_t * obj)
         return NULL;
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     lv_span_t * span = lv_ll_ins_tail(&spans->child_ll);
     LV_ASSERT_MALLOC(span);
@@ -183,7 +184,7 @@ void lv_spangroup_delete_span(lv_obj_t * obj, lv_span_t * span)
         return;
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     lv_span_t * cur_span;
     LV_LL_READ(&spans->child_ll, cur_span) {
@@ -331,7 +332,7 @@ void lv_spangroup_set_span_text_fmt(lv_obj_t * obj, lv_span_t * span, const char
 
 void lv_spangroup_set_span_style(lv_obj_t * obj, lv_span_t * span, const lv_style_t * style)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(span);
 
     lv_style_copy(&span->style, style);
@@ -348,7 +349,7 @@ void lv_spangroup_set_align(lv_obj_t * obj, lv_text_align_t align)
 
 void lv_spangroup_set_overflow(lv_obj_t * obj, lv_span_overflow_t overflow)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(spans->overflow == overflow) return;
     if(overflow >= LV_SPAN_OVERFLOW_LAST) return;
@@ -358,7 +359,7 @@ void lv_spangroup_set_overflow(lv_obj_t * obj, lv_span_overflow_t overflow)
 
 void lv_spangroup_set_indent(lv_obj_t * obj, int32_t indent)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(spans->indent == indent) return;
 
@@ -370,7 +371,7 @@ void lv_spangroup_set_indent(lv_obj_t * obj, int32_t indent)
 void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode)
 {
     LV_LOG_WARN("DEPRECATED, set the width to LV_SIZE_CONTENT or fixed value to control expanding/wrapping");
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     if(mode >= LV_SPAN_MODE_LAST) return;
 
@@ -400,7 +401,7 @@ void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode)
 
 void lv_spangroup_set_max_lines(lv_obj_t * obj, int32_t lines)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     spans->lines = lines;
 
@@ -427,7 +428,7 @@ lv_span_t * lv_spangroup_get_child(const lv_obj_t * obj, int32_t id)
         return NULL;
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     lv_ll_t * linked_list = &spans->child_ll;
 
@@ -460,13 +461,13 @@ lv_span_t * lv_spangroup_get_child(const lv_obj_t * obj, int32_t id)
 
 uint32_t lv_spangroup_get_span_count(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     if(obj == NULL) {
         return 0;
     }
 
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return lv_ll_get_len(&(spans->child_ll));
 }
@@ -478,21 +479,21 @@ lv_text_align_t lv_spangroup_get_align(lv_obj_t * obj)
 
 lv_span_overflow_t lv_spangroup_get_overflow(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->overflow;
 }
 
 int32_t lv_spangroup_get_indent(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->indent;
 }
 
 lv_span_mode_t lv_spangroup_get_mode(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     if(lv_obj_get_style_width(obj, LV_PART_MAIN) == LV_SIZE_CONTENT) {
         return LV_SPAN_MODE_EXPAND;
@@ -510,7 +511,7 @@ lv_span_mode_t lv_spangroup_get_mode(lv_obj_t * obj)
 
 int32_t lv_spangroup_get_max_lines(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->lines;
 }
@@ -518,7 +519,7 @@ int32_t lv_spangroup_get_max_lines(lv_obj_t * obj)
 
 int32_t lv_spangroup_get_max_line_height(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
 
     int32_t max_line_h = 0;
@@ -536,7 +537,7 @@ int32_t lv_spangroup_get_max_line_height(lv_obj_t * obj)
 
 uint32_t lv_spangroup_get_expand_width(lv_obj_t * obj, uint32_t max_width)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
 
     if(lv_ll_get_head(&spans->child_ll) == NULL) {
@@ -571,7 +572,7 @@ uint32_t lv_spangroup_get_expand_width(lv_obj_t * obj, uint32_t max_width)
 
 int32_t lv_spangroup_get_expand_height(lv_obj_t * obj, int32_t width)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(lv_ll_get_head(&spans->child_ll) == NULL || width <= 0) {
         return 0;

src/widgets/spinbox/lv_spinbox.c

@@ -12,6 +12,7 @@
 #if LV_USE_SPINBOX
 
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../core/lv_observer_private.h"
 
 /*Check dependencies*/
@@ -125,7 +126,7 @@ lv_obj_t * lv_spinbox_create(lv_obj_t * parent)
 
 void lv_spinbox_set_value(lv_obj_t * obj, int32_t v)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(v > spinbox->range_max) v = spinbox->range_max;
@@ -138,7 +139,7 @@ void lv_spinbox_set_value(lv_obj_t * obj, int32_t v)
 
 void lv_spinbox_set_rollover(lv_obj_t * obj, bool rollover)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->rollover = rollover;
@@ -146,7 +147,7 @@ void lv_spinbox_set_rollover(lv_obj_t * obj, bool rollover)
 
 void lv_spinbox_set_digit_format(lv_obj_t * obj, uint32_t digit_count, uint32_t sep_pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(digit_count > LV_SPINBOX_MAX_DIGIT_COUNT) digit_count = LV_SPINBOX_MAX_DIGIT_COUNT;
@@ -167,7 +168,7 @@ void lv_spinbox_set_digit_format(lv_obj_t * obj, uint32_t digit_count, uint32_t
 
 void lv_spinbox_set_digit_count(lv_obj_t * obj, uint32_t digit_count)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(digit_count > LV_SPINBOX_MAX_DIGIT_COUNT) digit_count = LV_SPINBOX_MAX_DIGIT_COUNT;
@@ -179,7 +180,7 @@ void lv_spinbox_set_digit_count(lv_obj_t * obj, uint32_t digit_count)
 
 void lv_spinbox_set_dec_point_pos(lv_obj_t * obj, uint32_t dec_point_pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->dec_point_pos = dec_point_pos;
@@ -189,7 +190,7 @@ void lv_spinbox_set_dec_point_pos(lv_obj_t * obj, uint32_t dec_point_pos)
 
 void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->step = step;
@@ -198,7 +199,7 @@ void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step)
 
 void lv_spinbox_set_range(lv_obj_t * obj, int32_t min_value, int32_t max_value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->range_max = max_value;
@@ -212,7 +213,7 @@ void lv_spinbox_set_range(lv_obj_t * obj, int32_t min_value, int32_t max_value)
 
 void lv_spinbox_set_min_value(lv_obj_t * obj, int32_t min_value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->range_min = min_value;
@@ -224,7 +225,7 @@ void lv_spinbox_set_min_value(lv_obj_t * obj, int32_t min_value)
 
 void lv_spinbox_set_max_value(lv_obj_t * obj, int32_t max_value)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->range_max = max_value;
@@ -236,7 +237,7 @@ void lv_spinbox_set_max_value(lv_obj_t * obj, int32_t max_value)
 
 void lv_spinbox_set_cursor_pos(lv_obj_t * obj, uint32_t pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     const int32_t step_limit = LV_MAX(spinbox->range_max, LV_ABS(spinbox->range_min));
@@ -250,7 +251,7 @@ void lv_spinbox_set_cursor_pos(lv_obj_t * obj, uint32_t pos)
 
 void lv_spinbox_set_digit_step_direction(lv_obj_t * obj, lv_dir_t direction)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     spinbox->digit_step_dir = direction;
 
@@ -262,7 +263,7 @@ void lv_spinbox_set_digit_step_direction(lv_obj_t * obj, lv_dir_t direction)
 
 int32_t lv_spinbox_get_value(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->value;
@@ -270,7 +271,7 @@ int32_t lv_spinbox_get_value(lv_obj_t * obj)
 
 int32_t lv_spinbox_get_step(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->step;
@@ -282,7 +283,7 @@ int32_t lv_spinbox_get_step(lv_obj_t * obj)
 
 void lv_spinbox_step_next(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     const int32_t new_step = spinbox->step / 10;
@@ -293,7 +294,7 @@ void lv_spinbox_step_next(lv_obj_t * obj)
 
 void lv_spinbox_step_prev(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     const int32_t step_limit = LV_MAX(spinbox->range_max, LV_ABS(spinbox->range_min));
@@ -305,7 +306,7 @@ void lv_spinbox_step_prev(lv_obj_t * obj)
 
 bool lv_spinbox_get_rollover(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->rollover;
@@ -313,42 +314,42 @@ bool lv_spinbox_get_rollover(lv_obj_t * obj)
 
 uint32_t lv_spinbox_get_digit_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     return spinbox->digit_count;
 }
 
 uint32_t lv_spinbox_get_dec_point_pos(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     return spinbox->dec_point_pos;
 }
 
 int32_t lv_spinbox_get_min_value(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     return spinbox->range_min;
 }
 
 int32_t lv_spinbox_get_max_value(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     return spinbox->range_max;
 }
 
 lv_dir_t lv_spinbox_get_digit_step_direction(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     return spinbox->digit_step_dir;
 }
 
 void lv_spinbox_increment(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     int32_t v = spinbox->value;
@@ -377,7 +378,7 @@ void lv_spinbox_increment(lv_obj_t * obj)
 
 void lv_spinbox_decrement(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     int32_t v = spinbox->value;

src/widgets/spinner/lv_spinner.c

@@ -8,6 +8,7 @@
  *********************/
 
 #include "lv_spinner_private.h"
+#include "../../misc/lv_check_obj.h"
 #if LV_USE_SPINNER
 
 #include "../../misc/lv_anim_private.h"
@@ -85,7 +86,7 @@ lv_obj_t * lv_spinner_create(lv_obj_t * parent)
 
 void lv_spinner_set_anim_params(lv_obj_t * obj, uint32_t t, uint32_t angle)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinner_t * spinner = (lv_spinner_t *)obj;
 
     spinner->duration = t;
@@ -116,7 +117,7 @@ void lv_spinner_set_anim_params(lv_obj_t * obj, uint32_t t, uint32_t angle)
 
 void lv_spinner_set_anim_duration(lv_obj_t * obj, uint32_t t)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinner_t * spinner = (lv_spinner_t *)obj;
 
     lv_spinner_set_anim_params(obj, t, spinner->angle);
@@ -124,7 +125,7 @@ void lv_spinner_set_anim_duration(lv_obj_t * obj, uint32_t t)
 
 void lv_spinner_set_arc_sweep(lv_obj_t * obj, uint32_t angle)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_spinner_t * spinner = (lv_spinner_t *)obj;
 
     lv_spinner_set_anim_params(obj, spinner->duration, angle);
@@ -132,14 +133,14 @@ void lv_spinner_set_arc_sweep(lv_obj_t * obj, uint32_t angle)
 
 uint32_t lv_spinner_get_anim_duration(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinner_t * spinner = (lv_spinner_t *)obj;
     return spinner->duration;
 }
 
 uint32_t lv_spinner_get_arc_sweep(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_spinner_t * spinner = (lv_spinner_t *)obj;
     return spinner->angle;
 }

src/widgets/switch/lv_switch.c

@@ -95,7 +95,7 @@ lv_obj_t * lv_switch_create(lv_obj_t * parent)
 
 void lv_switch_set_orientation(lv_obj_t * obj, lv_switch_orientation_t orientation)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_switch_t * sw = (lv_switch_t *)obj;
 
     sw->orientation = orientation;
@@ -108,7 +108,7 @@ void lv_switch_set_orientation(lv_obj_t * obj, lv_switch_orientation_t orientati
 
 lv_switch_orientation_t lv_switch_get_orientation(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_switch_t * sw = (lv_switch_t *)obj;
 
     return sw->orientation;
@@ -308,7 +308,7 @@ static void lv_switch_anim_completed(lv_anim_t * a)
  */
 static void lv_switch_trigger_anim(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     /*If the widget is not rendered yet show state changes immediately*/
     if(!obj->rendered) return;
 

src/widgets/table/lv_table.c

@@ -14,6 +14,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_text_private.h"
 #include "../../misc/lv_text_ap.h"
 #include "../../draw/lv_draw_private.h"
@@ -104,7 +105,7 @@ lv_obj_t * lv_table_create(lv_obj_t * parent)
 
 void lv_table_set_cell_value(lv_obj_t * obj, uint32_t row, uint32_t col, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(txt);
 
     lv_table_t * table = (lv_table_t *)obj;
@@ -139,7 +140,7 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint32_t row, uint32_t col, const c
 
 void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint32_t row, uint32_t col, const char * fmt, ...)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(fmt);
 
     lv_table_t * table = (lv_table_t *)obj;
@@ -217,7 +218,7 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint32_t row, uint32_t col, con
 
 void lv_table_set_row_count(lv_obj_t * obj, uint32_t row_cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -256,7 +257,7 @@ void lv_table_set_row_count(lv_obj_t * obj, uint32_t row_cnt)
 
 void lv_table_set_column_count(lv_obj_t * obj, uint32_t col_cnt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -311,7 +312,7 @@ void lv_table_set_column_count(lv_obj_t * obj, uint32_t col_cnt)
 
 void lv_table_set_column_width(lv_obj_t * obj, uint32_t col_id, int32_t w)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -324,7 +325,7 @@ void lv_table_set_column_width(lv_obj_t * obj, uint32_t col_id, int32_t w)
 
 void lv_table_set_cell_ctrl(lv_obj_t * obj, uint32_t row, uint32_t col, lv_table_cell_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -350,7 +351,7 @@ void lv_table_set_cell_ctrl(lv_obj_t * obj, uint32_t row, uint32_t col, lv_table
 
 void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint32_t row, uint32_t col, lv_table_cell_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -375,7 +376,7 @@ void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint32_t row, uint32_t col, lv_tab
 
 void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -400,7 +401,7 @@ void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, voi
 
 void lv_table_set_selected_cell(lv_obj_t * obj, uint16_t row, uint16_t col)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -424,7 +425,7 @@ void lv_table_set_selected_cell(lv_obj_t * obj, uint16_t row, uint16_t col)
 
 const char * lv_table_get_cell_value(lv_obj_t * obj, uint32_t row, uint32_t col)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_table_t * table = (lv_table_t *)obj;
     if(row >= table->row_cnt || col >= table->col_cnt) {
@@ -440,7 +441,7 @@ const char * lv_table_get_cell_value(lv_obj_t * obj, uint32_t row, uint32_t col)
 
 uint32_t lv_table_get_row_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_table_t * table = (lv_table_t *)obj;
     return table->row_cnt;
@@ -448,7 +449,7 @@ uint32_t lv_table_get_row_count(lv_obj_t * obj)
 
 uint32_t lv_table_get_column_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_table_t * table = (lv_table_t *)obj;
     return table->col_cnt;
@@ -456,7 +457,7 @@ uint32_t lv_table_get_column_count(lv_obj_t * obj)
 
 int32_t lv_table_get_column_width(lv_obj_t * obj, uint32_t col)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_table_t * table = (lv_table_t *)obj;
 
@@ -470,7 +471,7 @@ int32_t lv_table_get_column_width(lv_obj_t * obj, uint32_t col)
 
 bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint32_t row, uint32_t col, lv_table_cell_ctrl_t ctrl)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_table_t * table = (lv_table_t *)obj;
     if(row >= table->row_cnt || col >= table->col_cnt) {
@@ -492,7 +493,7 @@ void lv_table_get_selected_cell(lv_obj_t * obj, uint32_t * row, uint32_t * col)
 
 void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_table_t * table = (lv_table_t *)obj;
     if(row >= table->row_cnt || col >= table->col_cnt) {

src/widgets/tabview/lv_tabview.c

@@ -91,7 +91,7 @@ lv_obj_t * lv_tabview_create(lv_obj_t * parent)
 
 lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
     lv_obj_t * cont = lv_tabview_get_content(obj);
 
     lv_obj_t * page = lv_obj_create(cont);
@@ -121,7 +121,7 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
 
 void lv_tabview_set_tab_text(lv_obj_t * obj, uint32_t idx, const char * new_name)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_obj_t * tab_bar = lv_tabview_get_tab_bar(obj);
     lv_obj_t * button = lv_obj_get_child_by_type(tab_bar, idx, &lv_button_class);
@@ -133,7 +133,7 @@ void lv_tabview_set_tab_text(lv_obj_t * obj, uint32_t idx, const char * new_name
 
 lv_obj_t * lv_tabview_set_tab_translation_tag(lv_obj_t * obj, const char * tag)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_obj_t * page = lv_tabview_add_tab(obj, NULL);
     lv_obj_t * button = lv_tabview_get_tab_button(obj, -1);
@@ -147,7 +147,7 @@ lv_obj_t * lv_tabview_set_tab_translation_tag(lv_obj_t * obj, const char * tag)
 
 void lv_tabview_set_active(lv_obj_t * obj, uint32_t idx, lv_anim_enable_t anim_en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
 
     tabview->tab_cur = idx;
@@ -192,7 +192,7 @@ void lv_tabview_set_active(lv_obj_t * obj, uint32_t idx, lv_anim_enable_t anim_e
 
 void lv_tabview_set_tab_bar_position(lv_obj_t * obj, lv_dir_t dir)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
 
     switch(dir) {
@@ -263,7 +263,7 @@ void lv_tabview_set_tab_bar_position(lv_obj_t * obj, lv_dir_t dir)
 
 void lv_tabview_set_tab_bar_size(lv_obj_t * obj, int32_t size)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
 
     lv_obj_t * tab_bar = lv_tabview_get_tab_bar(obj);
@@ -278,21 +278,21 @@ void lv_tabview_set_tab_bar_size(lv_obj_t * obj, int32_t size)
 
 uint32_t lv_tabview_get_tab_active(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
     return tabview->tab_cur;
 }
 
 lv_obj_t * lv_tabview_get_tab_button(lv_obj_t * obj, int32_t idx)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     return lv_obj_get_child_by_type(lv_tabview_get_tab_bar(obj), idx, &lv_button_class);
 }
 
 uint32_t lv_tabview_get_tab_count(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_obj_t * tab_bar = lv_tabview_get_tab_bar(obj);
     return lv_obj_get_child_count_by_type(tab_bar, &lv_button_class);
 }
@@ -309,7 +309,7 @@ lv_obj_t * lv_tabview_get_tab_bar(lv_obj_t * tv)
 
 lv_dir_t lv_tabview_get_tab_bar_position(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
     return tabview->tab_pos;
 }

src/widgets/textarea/lv_textarea.c

@@ -12,6 +12,7 @@
 
 #include "../label/lv_label_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../misc/lv_check_obj.h"
 #include "../../misc/lv_anim_private.h"
 #include "../../misc/lv_text_private.h"
 
@@ -179,7 +180,7 @@ lv_obj_t * lv_textarea_create(lv_obj_t * parent)
 
 void lv_textarea_add_char(lv_obj_t * obj, uint32_t c)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     lv_result_t res = add_char(obj, c);
     if(res != LV_RESULT_OK) {
         return;
@@ -190,7 +191,7 @@ void lv_textarea_add_char(lv_obj_t * obj, uint32_t c)
 
 void lv_textarea_add_text(lv_obj_t * obj, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(txt);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -236,7 +237,7 @@ void lv_textarea_add_text(lv_obj_t * obj, const char * txt)
 
 void lv_textarea_delete_char(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     uint32_t cur_pos  = ta->cursor.pos;
@@ -280,7 +281,7 @@ void lv_textarea_delete_char(lv_obj_t * obj)
 
 void lv_textarea_delete_char_forward(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     uint32_t cp = lv_textarea_get_cursor_pos(obj);
     lv_textarea_set_cursor_pos(obj, cp + 1);
@@ -293,7 +294,7 @@ void lv_textarea_delete_char_forward(lv_obj_t * obj)
 
 void lv_textarea_set_text(lv_obj_t * obj, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(txt);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -333,7 +334,7 @@ void lv_textarea_set_text(lv_obj_t * obj, const char * txt)
 
 void lv_textarea_set_placeholder_text(lv_obj_t * obj, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     LV_ASSERT_NULL(txt);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -364,7 +365,7 @@ void lv_textarea_set_placeholder_text(lv_obj_t * obj, const char * txt)
 
 void lv_textarea_set_cursor_pos(lv_obj_t * obj, int32_t pos)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
     set_cursor_pos_internal(obj, pos);
 
     /*Position the label to make the cursor visible*/
@@ -375,7 +376,7 @@ void lv_textarea_set_cursor_pos(lv_obj_t * obj, int32_t pos)
 
 void lv_textarea_set_cursor_click_pos(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     ta->cursor.click_pos = en ? 1U : 0U;
@@ -383,7 +384,7 @@ void lv_textarea_set_cursor_click_pos(lv_obj_t * obj, bool en)
 
 void lv_textarea_set_password_mode(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->pwd_mode == en) return;
@@ -414,7 +415,7 @@ void lv_textarea_set_password_mode(lv_obj_t * obj, bool en)
 
 void lv_textarea_set_password_bullet(lv_obj_t * obj, const char * bullet)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -443,7 +444,7 @@ void lv_textarea_set_password_bullet(lv_obj_t * obj, const char * bullet)
 
 void lv_textarea_set_one_line(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->one_line == en) return;
@@ -470,7 +471,7 @@ void lv_textarea_set_one_line(lv_obj_t * obj, bool en)
 
 void lv_textarea_set_accepted_chars(lv_obj_t * obj, const char * list)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -487,7 +488,7 @@ void lv_textarea_set_accepted_chars(lv_obj_t * obj, const char * list)
 
 void lv_textarea_set_accepted_chars_static(lv_obj_t * obj, const char * list)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -499,7 +500,7 @@ void lv_textarea_set_accepted_chars_static(lv_obj_t * obj, const char * list)
 
 void lv_textarea_set_max_length(lv_obj_t * obj, uint32_t num)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -508,7 +509,7 @@ void lv_textarea_set_max_length(lv_obj_t * obj, uint32_t num)
 
 void lv_textarea_set_insert_replace(lv_obj_t * obj, const char * txt)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     LV_UNUSED(obj);
     ta_insert_replace = txt;
@@ -516,7 +517,7 @@ void lv_textarea_set_insert_replace(lv_obj_t * obj, const char * txt)
 
 void lv_textarea_set_text_selection(lv_obj_t * obj, bool en)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -532,7 +533,7 @@ void lv_textarea_set_text_selection(lv_obj_t * obj, bool en)
 
 void lv_textarea_set_password_show_time(lv_obj_t * obj, uint32_t time)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     ta->pwd_show_time = time;
@@ -564,7 +565,7 @@ void lv_textarea_set_align(lv_obj_t * obj, lv_text_align_t align)
 
 const char * lv_textarea_get_text(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -581,7 +582,7 @@ const char * lv_textarea_get_text(const lv_obj_t * obj)
 
 const char * lv_textarea_get_placeholder_text(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->placeholder_txt) return ta->placeholder_txt;
@@ -590,7 +591,7 @@ const char * lv_textarea_get_placeholder_text(lv_obj_t * obj)
 
 lv_obj_t * lv_textarea_get_label(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->label;
@@ -598,7 +599,7 @@ lv_obj_t * lv_textarea_get_label(const lv_obj_t * obj)
 
 uint32_t lv_textarea_get_cursor_pos(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->cursor.pos;
@@ -606,7 +607,7 @@ uint32_t lv_textarea_get_cursor_pos(const lv_obj_t * obj)
 
 bool lv_textarea_get_cursor_click_pos(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->cursor.click_pos;
@@ -614,7 +615,7 @@ bool lv_textarea_get_cursor_click_pos(lv_obj_t * obj)
 
 bool lv_textarea_get_password_mode(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->pwd_mode == 1U;
@@ -622,7 +623,7 @@ bool lv_textarea_get_password_mode(const lv_obj_t * obj)
 
 const char * lv_textarea_get_password_bullet(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -640,7 +641,7 @@ const char * lv_textarea_get_password_bullet(lv_obj_t * obj)
 
 bool lv_textarea_get_one_line(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->one_line == 1U;
@@ -648,7 +649,7 @@ bool lv_textarea_get_one_line(const lv_obj_t * obj)
 
 const char * lv_textarea_get_accepted_chars(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return NULL);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -657,7 +658,7 @@ const char * lv_textarea_get_accepted_chars(lv_obj_t * obj)
 
 uint32_t lv_textarea_get_max_length(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->max_length;
@@ -665,7 +666,7 @@ uint32_t lv_textarea_get_max_length(lv_obj_t * obj)
 
 bool lv_textarea_text_is_selected(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -685,7 +686,7 @@ bool lv_textarea_text_is_selected(const lv_obj_t * obj)
 
 bool lv_textarea_get_text_selection(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -698,7 +699,7 @@ bool lv_textarea_get_text_selection(lv_obj_t * obj)
 
 uint32_t lv_textarea_get_password_show_time(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return 0);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
 
@@ -707,7 +708,7 @@ uint32_t lv_textarea_get_password_show_time(lv_obj_t * obj)
 
 uint32_t lv_textarea_get_current_char(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     const char * txt = lv_textarea_get_text(obj);
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -724,7 +725,7 @@ uint32_t lv_textarea_get_current_char(lv_obj_t * obj)
 
 void lv_textarea_clear_selection(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
 #if LV_LABEL_TEXT_SELECTION
     lv_textarea_t * ta = (lv_textarea_t *)obj;
@@ -741,7 +742,7 @@ void lv_textarea_clear_selection(lv_obj_t * obj)
 
 void lv_textarea_cursor_right(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     uint32_t cp = lv_textarea_get_cursor_pos(obj);
     cp++;
@@ -750,7 +751,7 @@ void lv_textarea_cursor_right(lv_obj_t * obj)
 
 void lv_textarea_cursor_left(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     uint32_t cp = lv_textarea_get_cursor_pos(obj);
     if(cp > 0) {
@@ -761,7 +762,7 @@ void lv_textarea_cursor_left(lv_obj_t * obj)
 
 void lv_textarea_cursor_down(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     lv_point_t pos;
@@ -790,7 +791,7 @@ void lv_textarea_cursor_down(lv_obj_t * obj)
 
 void lv_textarea_cursor_up(lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;
     lv_point_t pos;
@@ -1489,7 +1490,7 @@ static void add_text(lv_obj_t * obj, const char * txt)
 }
 static lv_result_t add_char(lv_obj_t * obj, uint32_t c)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, true, return false);
 
     lv_textarea_t * ta = (lv_textarea_t *)obj;