refactor(obj): deprecate lv assert obj (#10009)

2026-10-06 19:00:49 +08:00 · 2026-06-09 18:55:23 +02:00
parent f6b4e6369d
commit 56e02402cc
60 changed files with 1393 additions and 689 deletions
@@ -26,19 +26,24 @@ else()
  include(${CMAKE_CURRENT_LIST_DIR}/env_support/cmake/main.cmake)
 endif()

-#[[
-    unfortunately CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS does not work for global data.
-    for global data we still need decl specs.
-    Check out the docs to learn more about the limitations of CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS
-    https://cmake.org/cmake/help/latest/prop_tgt/WINDOWS_EXPORT_ALL_SYMBOLS.html#prop_tgt:WINDOWS_EXPORT_ALL_SYMBOLS
+if(MSVC)
+  # Required for reliable variadic macro dispatch (e.g. LV_CHECK_OBJ) on MSVC.
+  target_compile_options(lvgl PUBLIC /Zc:preprocessor)

-    For all compiled sources within the library (i.e. basically all lvgl files) we need to use dllexport.
-    For all compiled sources from outside the library (i.e. files which include lvgl headers) we need to use dllimport.
-    We can do this by using CMakes INTERFACE and PRIVATE keyword.
-  ]]
-if(MSVC AND BUILD_SHARED_LIBS)
-  target_compile_definitions(
-    lvgl
-    INTERFACE "LV_ATTRIBUTE_EXTERN_DATA=__declspec(dllimport)"
-    PRIVATE "LV_ATTRIBUTE_EXTERN_DATA=__declspec(dllexport)")
+  #[[
+      unfortunately CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS does not work for global data.
+      for global data we still need decl specs.
+      Check out the docs to learn more about the limitations of CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS
+      https://cmake.org/cmake/help/latest/prop_tgt/WINDOWS_EXPORT_ALL_SYMBOLS.html#prop_tgt:WINDOWS_EXPORT_ALL_SYMBOLS
+
+      For all compiled sources within the library (i.e. basically all lvgl files) we need to use dllexport.
+      For all compiled sources from outside the library (i.e. files which include lvgl headers) we need to use dllimport.
+      We can do this by using CMakes INTERFACE and PRIVATE keyword.
+    ]]
+  if (BUILD_SHARED_LIBS)
+    target_compile_definitions(
+      lvgl
+      INTERFACE "LV_ATTRIBUTE_EXTERN_DATA=__declspec(dllimport)"
+      PRIVATE "LV_ATTRIBUTE_EXTERN_DATA=__declspec(dllexport)")
+  endif()
 endif()
@@ -854,8 +854,28 @@ menu "LVGL configuration"
 				config LV_CHECK_ARG_LOG_MODE_VERBOSE
 					bool "Verbose: log 'Check failed: <cond>' plus caller-supplied message"
 					depends on LV_USE_LOG
+
 			endchoice

+			config LV_USE_CHECK_OBJ_CLASSTYPE
+				bool "Enable class check in LV_CHECK_OBJ"
+				default y if !LV_CONF_MINIMAL
+				depends on LV_USE_CHECK_ARG
+				help
+					When enabled, LV_CHECK_OBJ verifies that the object has the
+					expected class (lv_obj_has_class). When disabled, the class
+					check is skipped even if a class argument is supplied.
+
+			config LV_USE_CHECK_OBJ_VALIDITY
+				bool "Enable widget-tree validity check in LV_CHECK_OBJ"
+				default y if !LV_CONF_MINIMAL
+				depends on LV_USE_CHECK_ARG
+				help
+					When enabled, LV_CHECK_OBJ also verifies that the object is
+					still part of the widget tree (lv_obj_is_valid). When disabled,
+					the validity check is skipped even if the associated argument
+					is supplied.
+
 			config LV_CHECK_ARG_LOG_MODE
 				int
 				depends on LV_USE_CHECK_ARG
@@ -1554,6 +1554,37 @@
    #endif
 #endif

+/** If enabled, LV_CHECK_OBJ will also verify that the object has the expected class.
+ * When disabled the class check is skipped even if the class argument is supplied.
+ * Requires LV_USE_CHECK_ARG to be enabled. */
+#ifndef LV_USE_CHECK_OBJ_CLASSTYPE
+    #ifdef LV_KCONFIG_PRESENT
+        #ifdef CONFIG_LV_USE_CHECK_OBJ_CLASSTYPE
+            #define LV_USE_CHECK_OBJ_CLASSTYPE CONFIG_LV_USE_CHECK_OBJ_CLASSTYPE
+        #else
+            #define LV_USE_CHECK_OBJ_CLASSTYPE 0
+        #endif
+    #else
+        #define LV_USE_CHECK_OBJ_CLASSTYPE 1
+    #endif
+#endif
+
+/** If enabled, LV_CHECK_OBJ will also verify that the object is still part of the
+ * widget tree (lv_obj_is_valid). When disabled the validity check is skipped even
+ * if the associated argument is supplied.
+ * Requires LV_USE_CHECK_ARG to be enabled. */
+#ifndef LV_USE_CHECK_OBJ_VALIDITY
+    #ifdef LV_KCONFIG_PRESENT
+        #ifdef CONFIG_LV_USE_CHECK_OBJ_VALIDITY
+            #define LV_USE_CHECK_OBJ_VALIDITY CONFIG_LV_USE_CHECK_OBJ_VALIDITY
+        #else
+            #define LV_USE_CHECK_OBJ_VALIDITY 0
+        #endif
+    #else
+        #define LV_USE_CHECK_OBJ_VALIDITY 1
+    #endif
+#endif
+
 /*-------------
 * Debug
 *-----------*/
@@ -506,14 +506,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
@@ -0,0 +1,85 @@
+/**
+ * @file lv_check_obj.h
+ *
+ */
+
+#ifndef LV_CHECK_OBJ_H
+#define LV_CHECK_OBJ_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../config/lv_conf_internal.h"
+#include "../logging/lv_log.h"
+#include "lv_check_arg.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#if LV_USE_CHECK_ARG
+
+#if LV_USE_CHECK_OBJ_CLASSTYPE
+    /**
+     * Check that `obj` is a descendant of the given class `cls`.
+     * Logs a warning and executes `action` if the check fails.
+     * Enabled when `LV_USE_CHECK_OBJ_CLASSTYPE = 1`; expands to a NULL check otherwise.
+     *
+     * @param obj     Pointer to the object to check.
+     * @param cls     Pointer to the expected `lv_obj_class_t` (e.g. `&lv_label_class`).
+     * @param action  Statement to execute on failure (e.g. `return false`).
+     */
+    #define LV_CHECK_OBJ_CLASS(obj, cls, action) \
+        LV_CHECK_ARG(obj != NULL, action); \
+        LV_CHECK_ARG(lv_obj_has_class(obj, cls), action);
+#else
+    #define LV_CHECK_OBJ_CLASS(obj, cls, action) LV_CHECK_ARG(obj != NULL, action);
+#endif
+
+#if LV_USE_CHECK_OBJ_VALIDITY
+    /**
+     * Check that `obj` is a live, reachable widget (i.e. part of the widget tree).
+     * Logs a warning and executes `action` if the check fails.
+     * Enabled when `LV_USE_CHECK_OBJ_VALIDITY = 1`; expands to nothing otherwise.
+     *
+     * @param obj     Pointer to the object to validate. Must not be NULL.
+     * @param action  Statement to execute on failure (e.g. `return false`).
+     */
+    #define LV_CHECK_OBJ_VALID(obj, cls, action) \
+      LV_CHECK_OBJ_CLASS(obj, cls, action); \
+      LV_CHECK_ARG(lv_obj_is_valid(obj), action);
+#else
+    #define LV_CHECK_OBJ_VALID(obj, cls, action) LV_CHECK_OBJ_CLASS(obj, cls, action);
+#endif
+
+#define LV_CHECK_OBJ(obj, cls, action) LV_CHECK_OBJ_VALID(obj, cls, action)
+
+#else
+
+#define LV_CHECK_OBJ_VALID(obj, cls, action)
+#define LV_CHECK_OBJ_CLASS(obj, cls, action)
+#define LV_CHECK_OBJ(obj, cls, action)
+
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CHECK_OBJ_H*/
@@ -50,6 +50,7 @@
 #include "core/lv_translation.h"
 #include "debugging/lv_assert.h"
 #include "debugging/lv_check_arg.h"
+#include "debugging/lv_check_obj.h"
 #include "debugging/lv_monkey.h"
 #include "debugging/lv_sysmon.h"
 #include "debugging/profiler/lv_profiler.h"
@@ -545,6 +545,17 @@
    #endif
 #endif

+/** If enabled, LV_CHECK_OBJ will also verify that the object has the expected class.
+ * When disabled the class check is skipped even if the class argument is supplied.
+ * Requires LV_USE_CHECK_ARG to be enabled. */
+#define LV_USE_CHECK_OBJ_CLASSTYPE 1
+
+/** If enabled, LV_CHECK_OBJ will also verify that the object is still part of the
+ * widget tree (lv_obj_is_valid). When disabled the validity check is skipped even
+ * if the associated argument is supplied.
+ * Requires LV_USE_CHECK_ARG to be enabled. */
+#define LV_USE_CHECK_OBJ_VALIDITY 1
+
 /*-------------
 * Debug
 *-----------*/
@@ -253,7 +253,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, MY_CLASS, return);

    if(lv_obj_has_flag(obj, f)) /*Check if all flags are set*/
        return;
@@ -293,7 +293,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, MY_CLASS, return);

    if(!lv_obj_has_flag_any(obj, f))
        return;
@@ -333,7 +333,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, MY_CLASS, return);

    lv_state_t new_state = obj->state | state;
    if(obj->state != new_state) {
@@ -346,7 +346,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, MY_CLASS, return);

    lv_state_t new_state = obj->state & (~state);
    if(obj->state != new_state) {
@@ -365,7 +365,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, MY_CLASS, return);
    obj->radio_button = en;
 }

@@ -375,41 +375,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, MY_CLASS, 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, MY_CLASS, 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, MY_CLASS, 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, MY_CLASS, 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, MY_CLASS, 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, MY_CLASS, return NULL);

    if(obj->spec_attr) return obj->spec_attr->group_p;
    else return NULL;
@@ -421,7 +421,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, MY_CLASS, return LV_RESULT_INVALID);
    LV_CHECK_ARG(child != NULL, return LV_RESULT_INVALID);

    uint16_t new_child_cnt = parent->spec_attr->child_cnt + 1;
@@ -440,8 +440,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, MY_CLASS, return);
+    LV_CHECK_OBJ(child, MY_CLASS, 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];
@@ -464,7 +464,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, MY_CLASS, return NULL);

    if(obj->spec_attr) {
        return obj->spec_attr;
@@ -1186,7 +1186,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, MY_CLASS, return);

    lv_state_t prev_state = obj->state;

@@ -1414,7 +1414,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, MY_CLASS, 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);
@@ -1439,7 +1439,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, MY_CLASS, 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;
@@ -7,9 +7,9 @@
 *      INCLUDES
 *********************/
 #include "lv_obj_class_private.h"
+#include "../lvgl_public.h"
 #include "lv_obj_private.h"
 #include "../display/lv_display_private.h"
-#include "../lvgl_public.h"

 /*********************
 *      DEFINES
@@ -89,7 +89,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, MY_CLASS, return NULL);

        if(!lv_obj_allocate_spec_attr(parent)) {
            lv_free(obj);
@@ -7,8 +7,8 @@
 *      INCLUDES
 *********************/
 #include "lv_obj_draw_private.h"
-#include "lv_obj_private.h"
 #include "../lvgl_public.h"
+#include "lv_obj_private.h"

 /*********************
 *      DEFINES
@@ -407,7 +407,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, MY_CLASS, return);

    int32_t s_old = lv_obj_get_ext_draw_size(obj);
    int32_t s_new = 0;
@@ -7,11 +7,11 @@
 *      INCLUDES
 *********************/
 #include "../misc/lv_event_private.h"
+#include "../lvgl_public.h"
 #include "lv_obj_event_private.h"
 #include "lv_obj_class_private.h"
 #include "lv_obj_private.h"
 #include "../indev/lv_indev_private.h"
-#include "../lvgl_public.h"

 /*********************
 *      DEFINES
@@ -51,7 +51,7 @@ lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void *
 {
    LV_CHECK_ARG(obj != NULL, return LV_RESULT_OK);

-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, return 0);

    lv_event_t e;
    e.current_target = obj;
@@ -106,7 +106,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_CHECK_ARG(event_cb != NULL, return NULL);
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, return 0);

    if(!lv_obj_allocate_spec_attr(obj)) {
        return NULL;
@@ -7,13 +7,13 @@
 *      INCLUDES
 *********************/
 #include "lv_obj_private.h"
+#include "../lvgl_public.h"
 #include "../misc/lv_anim_private.h"
 #include "lv_obj_style_private.h"
 #include "lv_obj_class_private.h"
 #include "../display/lv_display_private.h"
 #include "../core/lv_global.h"
 #include "lv_observer_private.h"
-#include "../lvgl_public.h"

 /*********************
 *      DEFINES
@@ -247,7 +247,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, MY_CLASS, return);

    if(!style_refr) return;

@@ -412,7 +412,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, MY_CLASS, return 0);

    uint32_t i;
    /*Find the style*/
@@ -7,6 +7,7 @@
 *      INCLUDES
 *********************/
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return 0);

    const lv_barcode_t * barcode = (const lv_barcode_t *)obj;
    return barcode->encoding;
@@ -7,6 +7,7 @@
 *      INCLUDES
 *********************/
 #include "lv_ffmpeg_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, return);
    lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
    if(player->decoder_name) {
        lv_free((void *)player->decoder_name);
@@ -9,6 +9,7 @@

 #include "lv_gstreamer_internal.h"

+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return);
    lv_gstreamer_t * streamer = (lv_gstreamer_t *)obj;

    if(!streamer->pipeline) {
@@ -7,6 +7,7 @@
 *      INCLUDES
 *********************/
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, return LV_RESULT_INVALID);
    lv_qrcode_t * qrcode = (lv_qrcode_t *)obj;

    lv_draw_buf_t * draw_buf = lv_canvas_get_draw_buf(obj);
@@ -1,2 +1,18 @@
 #warning Include public headers from the `src` folder is deprecated. This file will be removed soon. To ensure your application keeps working, you can choose to include the new header in <include/lvgl/config/lv_conf_internal.h> or include the main header file <include/lvgl/lvgl.h>
 #include "../include/lvgl/lvgl.h"
+#ifndef LV_USE_CHECK_OBJ_CLASSTYPE
+    #ifdef CONFIG_LV_USE_CHECK_OBJ_CLASSTYPE
+        #define LV_USE_CHECK_OBJ_CLASSTYPE CONFIG_LV_USE_CHECK_OBJ_CLASSTYPE
+    #else
+        #define LV_USE_CHECK_OBJ_CLASSTYPE 1
+    #endif
+#endif
+
+#ifndef LV_USE_CHECK_OBJ_VALIDITY
+    #ifdef CONFIG_LV_USE_CHECK_OBJ_VALIDITY
+        #define LV_USE_CHECK_OBJ_VALIDITY CONFIG_LV_USE_CHECK_OBJ_VALIDITY
+    #else
+        #define LV_USE_CHECK_OBJ_VALIDITY 1
+    #endif
+#endif
+
@@ -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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return);

    lv_file_explorer_t * explorer = (lv_file_explorer_t *)obj;

@@ -2,6 +2,7 @@
 #if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN

 #include "lv_tlsf_private.h"
+#include "../../lvgl_public.h"

 #undef  printf
 #define printf LV_LOG_ERROR
@@ -8,6 +8,7 @@
 *********************/

 #include "lv_3dtexture_private.h"
+#include "../../lvgl_public.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, 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, return);

    lv_3dtexture_t * tex = (lv_3dtexture_t *)obj;

@@ -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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return);
    lv_animimg_t * animimg = (lv_animimg_t *)obj;
    animimg->dsc = dsc;
    animimg->pic_count = num;
@@ -14,6 +14,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 &&
@@ -12,6 +12,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return false);

    lv_buttonmatrix_t * btnm = (lv_buttonmatrix_t *)obj;

@@ -14,6 +14,7 @@
 #include "../../draw/lv_draw_private.h"
 #include "../../core/lv_obj_class_private.h"

+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return LV_RESULT_INVALID);
    lv_calendar_t * calendar = (lv_calendar_t *)obj;

    uint32_t d = lv_buttonmatrix_get_selected_button(calendar->btnm);
@@ -16,6 +16,7 @@
 #if LV_USE_CANVAS

 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, return NULL);

    lv_canvas_t * canvas = (lv_canvas_t *)obj;
    return canvas->draw_buf;
@@ -209,7 +210,9 @@ 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, return (lv_color32_t) {
+        0
+    });

    lv_color32_t ret = { 0 };
    lv_canvas_t * canvas = (lv_canvas_t *)obj;
@@ -263,7 +266,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, return NULL);

    lv_canvas_t * canvas = (lv_canvas_t *)obj;
    return (lv_image_dsc_t *)canvas->draw_buf;
@@ -271,7 +274,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, return NULL);

    lv_canvas_t * canvas = (lv_canvas_t *)obj;
    if(canvas->draw_buf)
@@ -287,7 +290,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, return);
    LV_ASSERT_NULL(src_buf);

    lv_canvas_t * canvas = (lv_canvas_t *)obj;
@@ -300,7 +303,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, return);

    lv_canvas_t * canvas = (lv_canvas_t *)obj;
    lv_draw_buf_t * draw_buf = canvas->draw_buf;
@@ -13,6 +13,7 @@

 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return false);
    lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;

    return lv_obj_has_flag(dropdown->list, LV_OBJ_FLAG_HIDDEN) ? false : true;
@@ -8,6 +8,7 @@
 *********************/
 #include "../../lvgl_public.h"

+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return 0);
    lv_gif_t * gifobj = (lv_gif_t *) obj;

    if(!gifobj->is_open) {
@@ -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, 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, 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, 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, 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, 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, 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, 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, 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, return 0);

    lv_state_t obj_state = lv_obj_get_state(imagebutton);

@@ -7,6 +7,7 @@
 *      INCLUDES
 *********************/
 #include "lv_ime_pinyin_private.h"
+#include "../../lvgl_public.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, return);
    }

-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, 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, 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, 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, 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, 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, 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, return NULL);

    lv_ime_pinyin_t * pinyin_ime = (lv_ime_pinyin_t *)obj;

@@ -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, return);
    }

-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, 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, 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, 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, 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, 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, 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;
@@ -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 "../../lvgl_public.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../misc/lv_bidi_private.h"
 #include "../../misc/lv_text_ap.h"
@@ -128,7 +129,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, return);
    remove_translation_tag(obj);
    set_text_internal(obj, text);
 }
@@ -143,7 +144,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, return);
    LV_ASSERT_NULL(fmt);

    remove_translation_tag(obj);
@@ -170,7 +171,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, return);
    lv_label_t * label = (lv_label_t *)obj;

    remove_translation_tag(obj);
@@ -190,7 +191,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, return);
    lv_label_t * label = (lv_label_t *)obj;
    if(!tag || tag[0] == '\0') {
        return;
@@ -211,7 +212,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, return);

    lv_label_t * label = (lv_label_t *)obj;

@@ -232,7 +233,7 @@ void lv_label_set_long_mode(lv_obj_t * obj, lv_label_long_mode_t long_mode)

 void lv_label_set_max_lines(lv_obj_t * obj, int32_t lines)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, return);
    lv_label_t * label = (lv_label_t *)obj;
    label->max_lines = lines;
    lv_label_mark_need_refr_text(obj);
@@ -240,7 +241,7 @@ void lv_label_set_max_lines(lv_obj_t * obj, int32_t lines)

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

 #if LV_LABEL_TEXT_SELECTION
    lv_label_t * label = (lv_label_t *)obj;
@@ -254,7 +255,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, return);

 #if LV_LABEL_TEXT_SELECTION
    lv_label_t * label = (lv_label_t *)obj;
@@ -268,7 +269,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, return);

    lv_label_t * label = (lv_label_t *)obj;
    if(label->recolor == en) return;
@@ -285,28 +286,28 @@ 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, 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, return 0);
    lv_label_t * label = (lv_label_t *)obj;
    return label->long_mode;
 }

 int32_t lv_label_get_max_lines(const lv_obj_t * obj)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, return 0);
    const lv_label_t * label = (const lv_label_t *)obj;
    return label->max_lines;
 }

 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, return);
    LV_ASSERT_NULL(pos);

    lv_label_t * label = (lv_label_t *)obj;
@@ -424,7 +425,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, return 0);
    LV_ASSERT_NULL(pos_in);
    lv_label_t * label = (lv_label_t *)obj;

@@ -559,7 +560,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, return false);
    LV_ASSERT_NULL(pos);

    lv_area_t txt_coords;
@@ -642,7 +643,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, return 0);

 #if LV_LABEL_TEXT_SELECTION
    lv_label_t * label = (lv_label_t *)obj;
@@ -655,7 +656,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, return 0);

 #if LV_LABEL_TEXT_SELECTION
    lv_label_t * label = (lv_label_t *)obj;
@@ -668,7 +669,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, return false);

    lv_label_t * label = (lv_label_t *)obj;
    return label->recolor == 0 ? false : true;
@@ -714,7 +715,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, return);
    LV_ASSERT_NULL(txt);

    lv_label_t * label = (lv_label_t *)obj;
@@ -740,7 +741,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, return);
    lv_label_t * label = (lv_label_t *)obj;

    /*Cannot append to static text*/
@@ -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, 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, 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, return 0);

    lv_led_t * led = (lv_led_t *)obj;
    return led->bright;
@@ -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, 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, 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, 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, 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, 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, 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, return);

    lv_line_t * line = (lv_line_t *)obj;
    line->point_array.constant = points;
@@ -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, return NULL);
    lv_lottie_t * lottie = (lv_lottie_t *)obj;
    return lottie->anim;
 }
@@ -140,7 +140,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, return NULL);

    LV_LOG_INFO("begin");
    lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_page_class, menu);
@@ -173,7 +173,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, return NULL);

    LV_LOG_INFO("begin");
    lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_section_class, parent);
@@ -183,7 +183,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, return NULL);

    LV_LOG_INFO("begin");
    lv_obj_t * obj = lv_obj_class_create_obj(&lv_menu_separator_class, parent);
@@ -193,7 +193,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;
    lv_ll_t * history_ll = &(menu->history_ll);
@@ -221,7 +221,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -301,7 +301,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -364,7 +364,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -377,7 +377,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -389,7 +389,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, return);

    lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
    lv_obj_remove_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
@@ -429,7 +429,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, return);

    LV_LOG_INFO("begin");
    lv_menu_page_t * page = (lv_menu_page_t *)page_obj;
@@ -456,7 +456,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, return);

    LV_LOG_INFO("begin");
    lv_menu_page_t * page = (lv_menu_page_t *)page_obj;
@@ -483,7 +483,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->main_page;
@@ -491,7 +491,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->sidebar_page;
@@ -499,7 +499,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->main_header;
@@ -507,7 +507,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->main_header_back_btn;
@@ -515,7 +515,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->sidebar_header;
@@ -523,7 +523,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, return NULL);

    lv_menu_t * menu = (lv_menu_t *)obj;
    return menu->sidebar_header_back_btn;
@@ -531,7 +531,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, return false);

    if(obj == ((lv_menu_t *)menu)->sidebar_header_back_btn) {
        return true;
@@ -546,21 +546,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, 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, 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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;
    lv_ll_t * history_ll = &(menu->history_ll);
@@ -696,7 +696,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -731,7 +731,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, return);

    lv_menu_t * menu = (lv_menu_t *)obj;

@@ -13,6 +13,7 @@

 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, return NULL);
    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
    return mbox->title;
 }
@@ -14,6 +14,7 @@
 #include "../../misc/lv_anim_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, return LV_RESULT_INVALID);

    lv_obj_t * label = get_label(obj);
    uint32_t i;
@@ -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 "../../lvgl_public.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, return false);
    lv_slider_t * slider = (lv_slider_t *)obj;

    return slider->dragging;
@@ -13,6 +13,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../draw/lv_draw_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, return 0);

    if(obj == NULL) {
        return 0;
    }

-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_CHECK_OBJ(obj, MY_CLASS, 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, 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, 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, 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, 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, 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, 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, return 0);
    lv_spangroup_t * spans = (lv_spangroup_t *)obj;
    if(lv_ll_get_head(&spans->child_ll) == NULL || width <= 0) {
        return 0;
@@ -12,6 +12,7 @@
 #if LV_USE_SPINBOX

 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return);
    lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;

    int32_t v = spinbox->value;
@@ -8,6 +8,7 @@
 *********************/

 #include "lv_spinner_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, return 0);
    lv_spinner_t * spinner = (lv_spinner_t *)obj;
    return spinner->angle;
 }
@@ -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, 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, 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, return);
    /*If the widget is not rendered yet show state changes immediately*/
    if(!obj->rendered) return;

@@ -14,6 +14,7 @@
 #include "../../misc/lv_area_private.h"
 #include "../../core/lv_obj_private.h"
 #include "../../core/lv_obj_class_private.h"
+#include "../../lvgl_public.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return NULL);

    lv_table_t * table = (lv_table_t *)obj;
    if(row >= table->row_cnt || col >= table->col_cnt) {
@@ -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, 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, 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, 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, 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, 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, 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, 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, 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, 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, return 0);
    lv_tabview_t * tabview = (lv_tabview_t *)obj;
    return tabview->tab_pos;
 }
@@ -0,0 +1,55 @@
+#if LV_BUILD_TEST
+/* Variant: default — LV_USE_CHECK_ARG=1, LV_USE_CHECK_OBJ_CLASSTYPE=1, LV_USE_CHECK_OBJ_VALIDITY=1 */
+/* 1. Include the test conf manually so we can add overrides before lvgl.h */
+#include "lv_test_conf.h"
+/* 2. Prevent lv_conf_internal.h from re-including the conf */
+#define LV_CONF_SKIP
+#include "../lvgl.h"
+#include "test_cases/test_check_obj_impl.h"
+
+void setUp(void)
+{
+    log_warned = false;
+    last_log_buf[0] = '\0';
+    lv_log_register_print_cb(log_cb);
+}
+
+void tearDown(void)
+{
+    lv_log_register_print_cb(NULL);
+    lv_obj_clean(lv_screen_active());
+}
+
+void test_check_obj_null_check_pass(void)
+{
+    test_check_obj_null_check_pass_impl();
+}
+void test_check_obj_null_check_fail(void)
+{
+    test_check_obj_null_check_fail_impl();
+}
+void test_check_obj_class_correct_class_pass(void)
+{
+    test_check_obj_class_correct_class_pass_impl();
+}
+void test_check_obj_class_wrong_class_behavior(void)
+{
+    test_check_obj_class_wrong_class_behavior_impl();
+}
+void test_check_obj_class_null_still_fails(void)
+{
+    test_check_obj_class_null_still_fails_impl();
+}
+void test_check_obj_validity_valid_obj_pass(void)
+{
+    test_check_obj_validity_valid_obj_pass_impl();
+}
+void test_check_obj_validity_wrong_class_behavior(void)
+{
+    test_check_obj_validity_wrong_class_behavior_impl();
+}
+void test_check_obj_validity_null_still_fails(void)
+{
+    test_check_obj_validity_null_still_fails_impl();
+}
+#endif /* LV_BUILD_TEST */
@@ -0,0 +1,54 @@
+#if LV_BUILD_TEST
+/* Variant: LV_USE_CHECK_ARG=1, LV_USE_CHECK_OBJ_CLASSTYPE=1, LV_USE_CHECK_OBJ_VALIDITY=0 */
+#include "lv_test_conf.h"
+#define LV_USE_CHECK_OBJ_VALIDITY 0
+#define LV_CONF_SKIP
+#include "../lvgl.h"
+#include "test_cases/test_check_obj_impl.h"
+
+void setUp(void)
+{
+    log_warned = false;
+    last_log_buf[0] = '\0';
+    lv_log_register_print_cb(log_cb);
+}
+
+void tearDown(void)
+{
+    lv_log_register_print_cb(NULL);
+    lv_obj_clean(lv_screen_active());
+}
+
+void test_check_obj_null_check_pass(void)
+{
+    test_check_obj_null_check_pass_impl();
+}
+void test_check_obj_null_check_fail(void)
+{
+    test_check_obj_null_check_fail_impl();
+}
+void test_check_obj_class_correct_class_pass(void)
+{
+    test_check_obj_class_correct_class_pass_impl();
+}
+void test_check_obj_class_wrong_class_behavior(void)
+{
+    test_check_obj_class_wrong_class_behavior_impl();
+}
+void test_check_obj_class_null_still_fails(void)
+{
+    test_check_obj_class_null_still_fails_impl();
+}
+void test_check_obj_validity_valid_obj_pass(void)
+{
+    test_check_obj_validity_valid_obj_pass_impl();
+}
+void test_check_obj_validity_wrong_class_behavior(void)
+{
+    test_check_obj_validity_wrong_class_behavior_impl();
+}
+void test_check_obj_validity_null_still_fails(void)
+{
+    test_check_obj_validity_null_still_fails_impl();
+}
+#endif /* LV_BUILD_TEST */
@@ -0,0 +1,197 @@
+/**
+ * test_check_obj_impl.h
+ *
+ * Shared state, static-inline helpers, and test-body implementations for the
+ * test_check_obj_*.c config-variant suite.
+ *
+ * Why this file can be included directly
+ * --------------------------------------
+ * The Unity test-runner generator scans each .c file for quoted #include
+ * directives and re-emits them into the generated *_Runner.c. This header is
+ * safe to include directly because the shared test logic lives in static inline
+ * helpers, while each wrapper .c still provides the non-static test entry
+ * points that Unity calls.
+ *
+ * Why test functions are static inline *_impl variants
+ * ----------------------------------------------------
+ * Unity requires external linkage for test functions so the runner can resolve
+ * them via extern declarations. The static inline _impl functions hold the
+ * real test logic (compiled once per TU with the correct LV_USE_CHECK_*
+ * macros), while each .c wrapper provides thin non-static shims whose names
+ * match the void test_*() pattern the runner generator discovers.
+ */
+
+#ifndef TEST_CHECK_OBJ_IMPL_H
+#define TEST_CHECK_OBJ_IMPL_H
+
+#include "tests/unity/unity.h"
+#include <string.h>
+
+/* -------------------------------------------------------------------------
+ * Per-translation-unit state
+ * ---------------------------------------------------------------------- */
+
+#define TEST_ASSERT_LOG_CONTAINS(substr) \
+    do { \
+        if(strstr(last_log_buf, substr) == NULL) { \
+            TEST_PRINTF("Expected log to contain: '%s'. Actual log: '%s'", substr, last_log_buf); \
+            TEST_FAIL(); \
+        } \
+    } while(0)
+
+static bool log_warned;
+static char last_log_buf[512];
+
+/* -------------------------------------------------------------------------
+ * Static-inline helpers
+ * ---------------------------------------------------------------------- */
+
+static inline void log_cb(lv_log_level_t level, const char * buf)
+{
+    LV_UNUSED(level);
+    log_warned = true;
+    lv_strncpy(last_log_buf, buf, sizeof(last_log_buf) - 1);
+    last_log_buf[sizeof(last_log_buf) - 1] = '\0';
+}
+
+/* Exercises LV_CHECK_OBJ (full chain: NULL + class-type + validity). */
+static inline bool helper_null_check(lv_obj_t * obj)
+{
+    LV_CHECK_OBJ(obj, &lv_obj_class, return false);
+    LV_UNUSED(obj);
+    return true;
+}
+
+/* Exercises LV_CHECK_OBJ_CLASS (NULL + optional class-type check only). */
+static inline bool helper_class_check(lv_obj_t * obj, const lv_obj_class_t * cls)
+{
+    LV_CHECK_OBJ_CLASS(obj, cls, return false);
+    LV_UNUSED(obj);
+    LV_UNUSED(cls);
+    return true;
+}
+
+/* Exercises LV_CHECK_OBJ_VALID (NULL + class-type + optional validity check). */
+static inline bool helper_validity_check(lv_obj_t * obj, const lv_obj_class_t * cls)
+{
+    LV_CHECK_OBJ_VALID(obj, cls, return false);
+    LV_UNUSED(obj);
+    LV_UNUSED(cls);
+    return true;
+}
+
+/* -------------------------------------------------------------------------
+ * Test-body implementations (static inline)
+ *
+ * Called by the thin non-static shim functions defined in each .c wrapper,
+ * so every variant compiles its own copy with the right LV_USE_CHECK_* values.
+ * ---------------------------------------------------------------------- */
+
+/* --- NULL check (via LV_CHECK_OBJ with base class) --- */
+
+static inline void test_check_obj_null_check_pass_impl(void)
+{
+    lv_obj_t * obj = lv_obj_create(lv_screen_active());
+    log_warned = false; /* Ignore logs from object creation. */
+    bool result = helper_null_check(obj);
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+}
+
+static inline void test_check_obj_null_check_fail_impl(void)
+{
+    bool result = helper_null_check(NULL);
+#if LV_USE_CHECK_ARG
+    TEST_ASSERT_FALSE(result);
+    TEST_ASSERT_TRUE(log_warned);
+    TEST_ASSERT_LOG_CONTAINS("Check failed");
+#else
+    /* LV_CHECK_OBJ is a no-op: always returns true, never logs. */
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+#endif
+}
+
+/* --- Class check (via LV_CHECK_OBJ_CLASS: NULL + optional class-type) --- */
+
+static inline void test_check_obj_class_correct_class_pass_impl(void)
+{
+    lv_obj_t * label = lv_label_create(lv_screen_active());
+    log_warned = false; /* Ignore logs from object creation. */
+    bool result = helper_class_check(label, &lv_label_class);
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+}
+
+static inline void test_check_obj_class_wrong_class_behavior_impl(void)
+{
+    lv_obj_t * obj = lv_obj_create(lv_screen_active());
+    log_warned = false; /* Ignore logs from object creation. */
+    bool result = helper_class_check(obj, &lv_label_class);
+#if LV_USE_CHECK_ARG && LV_USE_CHECK_OBJ_CLASSTYPE
+    /* Class check is active: wrong class should fail. */
+    TEST_ASSERT_FALSE(result);
+    TEST_ASSERT_TRUE(log_warned);
+    TEST_ASSERT_LOG_CONTAINS("lv_obj_has_class");
+#else
+    /* Class check compiled out or CHECK_ARG disabled: passes silently. */
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+#endif
+}
+
+static inline void test_check_obj_class_null_still_fails_impl(void)
+{
+    /* NULL check always precedes class check. */
+    bool result = helper_class_check(NULL, &lv_label_class);
+#if LV_USE_CHECK_ARG
+    TEST_ASSERT_FALSE(result);
+    TEST_ASSERT_TRUE(log_warned);
+    TEST_ASSERT_LOG_CONTAINS("Check failed");
+#else
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+#endif
+}
+
+/* --- Validity check (via LV_CHECK_OBJ_VALID: NULL + class-type + optional validity) --- */
+
+static inline void test_check_obj_validity_valid_obj_pass_impl(void)
+{
+    lv_obj_t * label = lv_label_create(lv_screen_active());
+    log_warned = false; /* Ignore logs from object creation. */
+    bool result = helper_validity_check(label, &lv_label_class);
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+}
+
+static inline void test_check_obj_validity_wrong_class_behavior_impl(void)
+{
+    lv_obj_t * obj = lv_obj_create(lv_screen_active());
+    log_warned = false; /* Ignore logs from object creation. */
+    bool result = helper_validity_check(obj, &lv_label_class);
+#if LV_USE_CHECK_ARG && LV_USE_CHECK_OBJ_CLASSTYPE
+    /* Class check fires first in the 3-arg form. */
+    TEST_ASSERT_FALSE(result);
+    TEST_ASSERT_TRUE(log_warned);
+    TEST_ASSERT_LOG_CONTAINS("lv_obj_has_class");
+#else
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+#endif
+}
+
+static inline void test_check_obj_validity_null_still_fails_impl(void)
+{
+    bool result = helper_validity_check(NULL, &lv_label_class);
+#if LV_USE_CHECK_ARG
+    TEST_ASSERT_FALSE(result);
+    TEST_ASSERT_TRUE(log_warned);
+    TEST_ASSERT_LOG_CONTAINS("Check failed");
+#else
+    TEST_ASSERT_TRUE(result);
+    TEST_ASSERT_FALSE(log_warned);
+#endif
+}
+
+#endif /* TEST_CHECK_OBJ_IMPL_H */
@@ -0,0 +1,54 @@
+#if LV_BUILD_TEST
+/* Variant: LV_USE_CHECK_ARG=0 */
+#include "lv_test_conf.h"
+#define LV_USE_CHECK_ARG 0
+#define LV_CONF_SKIP
+#include "../lvgl.h"
+#include "test_cases/test_check_obj_impl.h"
+
+void setUp(void)
+{
+    log_warned = false;
+    last_log_buf[0] = '\0';
+    lv_log_register_print_cb(log_cb);
+}
+
+void tearDown(void)
+{
+    lv_log_register_print_cb(NULL);
+    lv_obj_clean(lv_screen_active());
+}
+
+void test_check_obj_null_check_pass(void)
+{
+    test_check_obj_null_check_pass_impl();
+}
+void test_check_obj_null_check_fail(void)
+{
+    test_check_obj_null_check_fail_impl();
+}
+void test_check_obj_class_correct_class_pass(void)
+{
+    test_check_obj_class_correct_class_pass_impl();
+}
+void test_check_obj_class_wrong_class_behavior(void)
+{
+    test_check_obj_class_wrong_class_behavior_impl();
+}
+void test_check_obj_class_null_still_fails(void)
+{
+    test_check_obj_class_null_still_fails_impl();
+}
+void test_check_obj_validity_valid_obj_pass(void)
+{
+    test_check_obj_validity_valid_obj_pass_impl();
+}
+void test_check_obj_validity_wrong_class_behavior(void)
+{
+    test_check_obj_validity_wrong_class_behavior_impl();
+}
+void test_check_obj_validity_null_still_fails(void)
+{
+    test_check_obj_validity_null_still_fails_impl();
+}
+#endif /* LV_BUILD_TEST */
@@ -0,0 +1,55 @@
+#if LV_BUILD_TEST
+/* Variant: LV_USE_CHECK_ARG=1, LV_USE_CHECK_OBJ_CLASSTYPE=0, LV_USE_CHECK_OBJ_VALIDITY=0 */
+#include "lv_test_conf.h"
+#define LV_USE_CHECK_OBJ_CLASSTYPE 0
+#define LV_USE_CHECK_OBJ_VALIDITY 0
+#define LV_CONF_SKIP
+#include "../lvgl.h"
+#include "test_cases/test_check_obj_impl.h"
+
+void setUp(void)
+{
+    log_warned = false;
+    last_log_buf[0] = '\0';
+    lv_log_register_print_cb(log_cb);
+}
+
+void tearDown(void)
+{
+    lv_log_register_print_cb(NULL);
+    lv_obj_clean(lv_screen_active());
+}
+
+void test_check_obj_null_check_pass(void)
+{
+    test_check_obj_null_check_pass_impl();
+}
+void test_check_obj_null_check_fail(void)
+{
+    test_check_obj_null_check_fail_impl();
+}
+void test_check_obj_class_correct_class_pass(void)
+{
+    test_check_obj_class_correct_class_pass_impl();
+}
+void test_check_obj_class_wrong_class_behavior(void)
+{
+    test_check_obj_class_wrong_class_behavior_impl();
+}
+void test_check_obj_class_null_still_fails(void)
+{
+    test_check_obj_class_null_still_fails_impl();
+}
+void test_check_obj_validity_valid_obj_pass(void)
+{
+    test_check_obj_validity_valid_obj_pass_impl();
+}
+void test_check_obj_validity_wrong_class_behavior(void)
+{
+    test_check_obj_validity_wrong_class_behavior_impl();
+}
+void test_check_obj_validity_null_still_fails(void)
+{
+    test_check_obj_validity_null_still_fails_impl();
+}
+#endif /* LV_BUILD_TEST */
@@ -0,0 +1,54 @@
+#if LV_BUILD_TEST
+/* Variant: LV_USE_CHECK_ARG=1, LV_USE_CHECK_OBJ_CLASSTYPE=0, LV_USE_CHECK_OBJ_VALIDITY=1 */
+#include "lv_test_conf.h"
+#define LV_USE_CHECK_OBJ_CLASSTYPE 0
+#define LV_CONF_SKIP
+#include "../lvgl.h"
+#include "test_cases/test_check_obj_impl.h"
+
+void setUp(void)
+{
+    log_warned = false;
+    last_log_buf[0] = '\0';
+    lv_log_register_print_cb(log_cb);
+}
+
+void tearDown(void)
+{
+    lv_log_register_print_cb(NULL);
+    lv_obj_clean(lv_screen_active());
+}
+
+void test_check_obj_null_check_pass(void)
+{
+    test_check_obj_null_check_pass_impl();
+}
+void test_check_obj_null_check_fail(void)
+{
+    test_check_obj_null_check_fail_impl();
+}
+void test_check_obj_class_correct_class_pass(void)
+{
+    test_check_obj_class_correct_class_pass_impl();
+}
+void test_check_obj_class_wrong_class_behavior(void)
+{
+    test_check_obj_class_wrong_class_behavior_impl();
+}
+void test_check_obj_class_null_still_fails(void)
+{
+    test_check_obj_class_null_still_fails_impl();
+}
+void test_check_obj_validity_valid_obj_pass(void)
+{
+    test_check_obj_validity_valid_obj_pass_impl();
+}
+void test_check_obj_validity_wrong_class_behavior(void)
+{
+    test_check_obj_validity_wrong_class_behavior_impl();
+}
+void test_check_obj_validity_null_still_fails(void)
+{
+    test_check_obj_validity_null_still_fails_impl();
+}
+#endif /* LV_BUILD_TEST */