dubug: add asserts to every object type's API functions

src/lv_core/lv_obj.c

@@ -2302,7 +2302,7 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
  * @param name name of the object. E.g. "lv_btn". (Only teh pointer is saved)
  * @return LV_RES_OK
  */
-lv_res_t lv_obj_handle_get_type_signal(lv_obj_t * obj, lv_obj_type_t * buf, const char * name)
+lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name)
 {
     uint8_t i;
     for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
@@ -2381,7 +2381,7 @@ static bool lv_obj_design(lv_obj_t * obj, const lv_area_t * mask_p, lv_design_mo
  */
 static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
 {
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(obj, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_res_t res = LV_RES_OK;
 

src/lv_core/lv_obj.h

@@ -966,12 +966,11 @@ bool lv_obj_is_focused(const lv_obj_t * obj);
 
 /**
  * Used in the signal callback to handle `LV_SIGNAL_GET_TYPE` signal
- * @param obj pointer to an object
  * @param buf pointer to `lv_obj_type_t`. (`param` i nteh signal callback)
  * @param name name of the object. E.g. "lv_btn". (Only teh pointer is saved)
  * @return LV_RES_OK
  */
-lv_res_t lv_obj_handle_get_type_signal(lv_obj_t * obj, lv_obj_type_t * buf, const char * name);
+lv_res_t lv_obj_handle_get_type_signal(lv_obj_type_t * buf, const char * name);
 
 /**********************
  *      MACROS

src/lv_objx/lv_arc.c

@@ -121,6 +121,8 @@ lv_obj_t * lv_arc_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_arc_set_angles(lv_obj_t * arc, uint16_t start, uint16_t end)
 {
+    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);
+
     lv_arc_ext_t * ext = lv_obj_get_ext_attr(arc);
 
     if(start > 360) start = 360;
@@ -140,6 +142,8 @@ void lv_arc_set_angles(lv_obj_t * arc, uint16_t start, uint16_t end)
  *  */
 void lv_arc_set_style(lv_obj_t * arc, lv_arc_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);
+
     switch(type) {
         case LV_ARC_STYLE_MAIN: lv_obj_set_style(arc, style); break;
     }
@@ -156,6 +160,8 @@ void lv_arc_set_style(lv_obj_t * arc, lv_arc_style_t type, const lv_style_t * st
  */
 uint16_t lv_arc_get_angle_start(lv_obj_t * arc)
 {
+    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);
+
     lv_arc_ext_t * ext = lv_obj_get_ext_attr(arc);
 
     return ext->angle_start;
@@ -168,6 +174,8 @@ uint16_t lv_arc_get_angle_start(lv_obj_t * arc)
  */
 uint16_t lv_arc_get_angle_end(lv_obj_t * arc)
 {
+    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);
+
     lv_arc_ext_t * ext = lv_obj_get_ext_attr(arc);
 
     return ext->angle_end;
@@ -181,6 +189,8 @@ uint16_t lv_arc_get_angle_end(lv_obj_t * arc)
  *  */
 const lv_style_t * lv_arc_get_style(const lv_obj_t * arc, lv_arc_style_t type)
 {
+    LV_ASSERT_OBJ(arc, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
 
     switch(type) {
@@ -283,7 +293,7 @@ static lv_res_t lv_arc_signal(lv_obj_t * arc, lv_signal_t sign, void * param)
     res = ancestor_signal(arc, sign, param);
     if(res != LV_RES_OK) return res;
 
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(arc, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_bar.c

@@ -132,6 +132,8 @@ lv_obj_t * lv_bar_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_bar_set_value(lv_obj_t * bar, int16_t value, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = false;
 #endif
@@ -187,6 +189,8 @@ void lv_bar_set_value(lv_obj_t * bar, int16_t value, lv_anim_enable_t anim)
  */
 void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     if(ext->min_value == min && ext->max_value == max) return;
 
@@ -211,6 +215,8 @@ void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
  */
 void lv_bar_set_sym(lv_obj_t * bar, bool en)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     ext->sym           = en ? 1 : 0;
 }
@@ -222,6 +228,8 @@ void lv_bar_set_sym(lv_obj_t * bar, bool en)
  */
 void lv_bar_set_anim_time(lv_obj_t * bar, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     ext->anim_time     = anim_time;
@@ -239,6 +247,8 @@ void lv_bar_set_anim_time(lv_obj_t * bar, uint16_t anim_time)
  */
 void lv_bar_set_style(lv_obj_t * bar, lv_bar_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
 
     switch(type) {
@@ -261,6 +271,8 @@ void lv_bar_set_style(lv_obj_t * bar, lv_bar_style_t type, const lv_style_t * st
  */
 int16_t lv_bar_get_value(const lv_obj_t * bar)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     /*If animated tell that it's already at the end value*/
 #if LV_USE_ANIMATION
@@ -277,6 +289,8 @@ int16_t lv_bar_get_value(const lv_obj_t * bar)
  */
 int16_t lv_bar_get_min_value(const lv_obj_t * bar)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     return ext->min_value;
 }
@@ -288,6 +302,8 @@ int16_t lv_bar_get_min_value(const lv_obj_t * bar)
  */
 int16_t lv_bar_get_max_value(const lv_obj_t * bar)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     return ext->max_value;
 }
@@ -299,6 +315,8 @@ int16_t lv_bar_get_max_value(const lv_obj_t * bar)
  */
 bool lv_bar_get_sym(lv_obj_t * bar)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     return ext->sym ? true : false;
 }
@@ -310,6 +328,8 @@ bool lv_bar_get_sym(lv_obj_t * bar)
  */
 uint16_t lv_bar_get_anim_time(lv_obj_t * bar)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
     return ext->anim_time;
@@ -327,6 +347,8 @@ uint16_t lv_bar_get_anim_time(lv_obj_t * bar)
  */
 const lv_style_t * lv_bar_get_style(const lv_obj_t * bar, lv_bar_style_t type)
 {
+    LV_ASSERT_OBJ(bar, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_bar_ext_t * ext       = lv_obj_get_ext_attr(bar);
 
@@ -497,7 +519,7 @@ static lv_res_t lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(bar, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(bar, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         const lv_style_t * style_indic = lv_bar_get_style(bar, LV_BAR_STYLE_INDIC);

src/lv_objx/lv_btn.c

@@ -160,6 +160,8 @@ lv_obj_t * lv_btn_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_btn_set_toggle(lv_obj_t * btn, bool tgl)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
 
     ext->toggle = tgl != false ? 1 : 0;
@@ -172,6 +174,8 @@ void lv_btn_set_toggle(lv_obj_t * btn, bool tgl)
  */
 void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     if(ext->state != state) {
         ext->state = state;
@@ -185,6 +189,8 @@ void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state)
  */
 void lv_btn_toggle(lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     switch(ext->state) {
         case LV_BTN_STATE_REL: lv_btn_set_state(btn, LV_BTN_STATE_TGL_REL); break;
@@ -202,6 +208,8 @@ void lv_btn_toggle(lv_obj_t * btn)
  */
 void lv_btn_set_ink_in_time(lv_obj_t * btn, uint16_t time)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     ext->ink_in_time   = time;
@@ -220,6 +228,8 @@ void lv_btn_set_ink_in_time(lv_obj_t * btn, uint16_t time)
  */
 void lv_btn_set_ink_wait_time(lv_obj_t * btn, uint16_t time)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
@@ -239,6 +249,8 @@ void lv_btn_set_ink_wait_time(lv_obj_t * btn, uint16_t time)
  */
 void lv_btn_set_ink_out_time(lv_obj_t * btn, uint16_t time)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     ext->ink_out_time  = time;
@@ -258,6 +270,8 @@ void lv_btn_set_ink_out_time(lv_obj_t * btn, uint16_t time)
  */
 void lv_btn_set_style(lv_obj_t * btn, lv_btn_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
 
     switch(type) {
@@ -283,6 +297,8 @@ void lv_btn_set_style(lv_obj_t * btn, lv_btn_style_t type, const lv_style_t * st
  */
 lv_btn_state_t lv_btn_get_state(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     return ext->state;
 }
@@ -294,6 +310,8 @@ lv_btn_state_t lv_btn_get_state(const lv_obj_t * btn)
  */
 bool lv_btn_get_toggle(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
 
     return ext->toggle != 0 ? true : false;
@@ -306,6 +324,8 @@ bool lv_btn_get_toggle(const lv_obj_t * btn)
  */
 uint16_t lv_btn_get_ink_in_time(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     return ext->ink_in_time;
@@ -322,6 +342,8 @@ uint16_t lv_btn_get_ink_in_time(const lv_obj_t * btn)
  */
 uint16_t lv_btn_get_ink_wait_time(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     return ext->ink_wait_time;
@@ -337,6 +359,8 @@ uint16_t lv_btn_get_ink_wait_time(const lv_obj_t * btn)
  */
 uint16_t lv_btn_get_ink_out_time(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION && LV_BTN_INK_EFFECT
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     return ext->ink_in_time;
@@ -354,6 +378,8 @@ uint16_t lv_btn_get_ink_out_time(const lv_obj_t * btn)
  */
 const lv_style_t * lv_btn_get_style(const lv_obj_t * btn, lv_btn_style_t type)
 {
+    LV_ASSERT_OBJ(btn, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_btn_ext_t * ext       = lv_obj_get_ext_attr(btn);
     lv_btn_state_t state     = lv_btn_get_state(btn);
@@ -485,7 +511,7 @@ static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(btn, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(btn, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
     bool tgl           = lv_btn_get_toggle(btn);

src/lv_objx/lv_btnm.c

@@ -103,8 +103,8 @@ lv_obj_t * lv_btnm_create(lv_obj_t * par, const lv_obj_t * copy)
 
     /*Init the new button matrix object*/
     if(copy == NULL) {
-        lv_obj_set_size(new_btnm, LV_DPI * 3, LV_DPI * 2);
         lv_btnm_set_map(new_btnm, lv_btnm_def_map);
+        lv_obj_set_size(new_btnm, LV_DPI * 3, LV_DPI * 2);
 
         /*Set the default styles*/
         lv_theme_t * th = lv_theme_get_current();
@@ -144,7 +144,8 @@ lv_obj_t * lv_btnm_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_btnm_set_map(const lv_obj_t * btnm, const char * map[])
 {
-    if(map == NULL) return;
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+    LV_ASSERT_NULL(map);
 
     /*
      * lv_btnm_set_map is called on receipt of signals such as
@@ -267,6 +268,8 @@ void lv_btnm_set_map(const lv_obj_t * btnm, const char * map[])
  */
 void lv_btnm_set_ctrl_map(const lv_obj_t * btnm, const lv_btnm_ctrl_t ctrl_map[])
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     memcpy(ext->ctrl_bits, ctrl_map, sizeof(lv_btnm_ctrl_t) * ext->btn_cnt);
 
@@ -281,6 +284,8 @@ void lv_btnm_set_ctrl_map(const lv_obj_t * btnm, const lv_btnm_ctrl_t ctrl_map[]
  */
 void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     if(id >= ext->btn_cnt && id != LV_BTNM_BTN_NONE) return;
@@ -299,6 +304,8 @@ void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id)
  */
 void lv_btnm_set_style(lv_obj_t * btnm, lv_btnm_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     switch(type) {
@@ -333,6 +340,8 @@ void lv_btnm_set_style(lv_obj_t * btnm, lv_btnm_style_t type, const lv_style_t *
  */
 void lv_btnm_set_recolor(const lv_obj_t * btnm, bool en)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     ext->recolor = en;
@@ -346,6 +355,8 @@ void lv_btnm_set_recolor(const lv_obj_t * btnm, bool en)
  */
 void lv_btnm_set_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t ctrl)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     if(btn_id >= ext->btn_cnt) return;
@@ -361,6 +372,8 @@ void lv_btnm_set_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t
  */
 void lv_btnm_clear_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t ctrl)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     if(btn_id >= ext->btn_cnt) return;
@@ -376,6 +389,8 @@ void lv_btnm_clear_btn_ctrl(const lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl
  */
 void lv_btnm_set_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     uint16_t i;
     for(i = 0; i < ext->btn_cnt; i++) {
@@ -391,6 +406,8 @@ void lv_btnm_set_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
  */
 void lv_btnm_clear_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     uint16_t i;
     for(i = 0; i < ext->btn_cnt; i++) {
@@ -409,6 +426,8 @@ void lv_btnm_clear_btn_ctrl_all(lv_obj_t * btnm, lv_btnm_ctrl_t ctrl)
  */
 void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
 
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     if(btn_id >= ext->btn_cnt) return;
@@ -429,6 +448,8 @@ void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width
  */
 void lv_btnm_set_one_toggle(lv_obj_t * btnm, bool one_toggle)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     ext->one_toggle     = one_toggle;
 
@@ -447,6 +468,8 @@ void lv_btnm_set_one_toggle(lv_obj_t * btnm, bool one_toggle)
  */
 const char ** lv_btnm_get_map_array(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     return ext->map_p;
 }
@@ -458,6 +481,8 @@ const char ** lv_btnm_get_map_array(const lv_obj_t * btnm)
  */
 bool lv_btnm_get_recolor(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     return ext->recolor;
@@ -471,6 +496,8 @@ bool lv_btnm_get_recolor(const lv_obj_t * btnm)
  */
 uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     return ext->btn_id_act;
 }
@@ -483,6 +510,8 @@ uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm)
  */
 const char * lv_btnm_get_active_btn_text(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     if(ext->btn_id_act != LV_BTNM_BTN_NONE) {
         return lv_btnm_get_btn_text(btnm, ext->btn_id_act);
@@ -499,6 +528,8 @@ const char * lv_btnm_get_active_btn_text(const lv_obj_t * btnm)
  */
 uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     return ext->btn_id_pr;
 }
@@ -512,6 +543,8 @@ uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm)
  */
 const char * lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     if(btn_id > ext->btn_cnt) return NULL;
 
@@ -541,6 +574,8 @@ const char * lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
  */
 bool lv_btnm_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t ctrl)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     if(btn_id >= ext->btn_cnt) return false;
 
@@ -555,6 +590,8 @@ bool lv_btnm_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnm_ctrl_t ctrl)
  */
 const lv_style_t * lv_btnm_get_style(const lv_obj_t * btnm, lv_btnm_style_t type)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_btnm_ext_t * ext      = lv_obj_get_ext_attr(btnm);
 
@@ -578,6 +615,8 @@ const lv_style_t * lv_btnm_get_style(const lv_obj_t * btnm, lv_btnm_style_t type
  */
 bool lv_btnm_get_one_toggle(const lv_obj_t * btnm)
 {
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
 
     return ext->one_toggle;
@@ -715,7 +754,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(btnm, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(btnm, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
     lv_point_t p;

src/lv_objx/lv_calendar.c

@@ -197,6 +197,9 @@ lv_obj_t * lv_calendar_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_calendar_set_today_date(lv_obj_t * calendar, lv_calendar_date_t * today)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+    LV_ASSERT_NULL(today);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     ext->today.year         = today->year;
     ext->today.month        = today->month;
@@ -213,6 +216,9 @@ void lv_calendar_set_today_date(lv_obj_t * calendar, lv_calendar_date_t * today)
  */
 void lv_calendar_set_showed_date(lv_obj_t * calendar, lv_calendar_date_t * showed)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+    LV_ASSERT_NULL(showed);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     ext->showed_date.year   = showed->year;
     ext->showed_date.month  = showed->month;
@@ -230,6 +236,9 @@ void lv_calendar_set_showed_date(lv_obj_t * calendar, lv_calendar_date_t * showe
  */
 void lv_calendar_set_highlighted_dates(lv_obj_t * calendar, lv_calendar_date_t * highlighted, uint16_t date_num)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+    LV_ASSERT_NULL(highlighted);
+
     lv_calendar_ext_t * ext    = lv_obj_get_ext_attr(calendar);
     ext->highlighted_dates     = highlighted;
     ext->highlighted_dates_num = date_num;
@@ -246,6 +255,9 @@ void lv_calendar_set_highlighted_dates(lv_obj_t * calendar, lv_calendar_date_t *
  */
 void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+    LV_ASSERT_NULL(day_names);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     ext->day_names          = day_names;
     lv_obj_invalidate(calendar);
@@ -254,14 +266,17 @@ void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names)
 /**
  * Set the name of the month
  * @param calendar pointer to a calendar object
- * @param day_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
+ * @param month_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
  * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
  * later.
  */
-void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** day_names)
+void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** month_names)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+    LV_ASSERT_NULL(month_names);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
-    ext->month_names        = day_names;
+    ext->month_names        = month_names;
     lv_obj_invalidate(calendar);
 }
 
@@ -273,6 +288,8 @@ void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** day_names)
  *  */
 void lv_calendar_set_style(lv_obj_t * calendar, lv_calendar_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
 
     switch(type) {
@@ -300,6 +317,8 @@ void lv_calendar_set_style(lv_obj_t * calendar, lv_calendar_style_t type, const
  */
 lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return &ext->today;
 }
@@ -311,6 +330,8 @@ lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * calendar)
  */
 lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return &ext->showed_date;
 }
@@ -323,6 +344,8 @@ lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * calendar)
  */
 lv_calendar_date_t * lv_calendar_get_pressed_date(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return ext->pressed_date.year != 0 ? &ext->pressed_date : NULL;
 }
@@ -334,6 +357,8 @@ lv_calendar_date_t * lv_calendar_get_pressed_date(const lv_obj_t * calendar)
  */
 lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return ext->highlighted_dates;
 }
@@ -345,6 +370,8 @@ lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * calendar
  */
 uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return ext->highlighted_dates_num;
 }
@@ -356,6 +383,8 @@ uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * calendar)
  */
 const char ** lv_calendar_get_day_names(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return ext->day_names;
 }
@@ -367,6 +396,8 @@ const char ** lv_calendar_get_day_names(const lv_obj_t * calendar)
  */
 const char ** lv_calendar_get_month_names(const lv_obj_t * calendar)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
     return ext->month_names;
 }
@@ -379,6 +410,8 @@ const char ** lv_calendar_get_month_names(const lv_obj_t * calendar)
  *  */
 const lv_style_t * lv_calendar_get_style(const lv_obj_t * calendar, lv_calendar_style_t type)
 {
+    LV_ASSERT_OBJ(calendar, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_calendar_ext_t * ext  = lv_obj_get_ext_attr(calendar);
 
@@ -456,7 +489,7 @@ static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void *
     /* Include the ancient signal function */
     res = ancestor_signal(calendar, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(calendar, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_calendar.h

@@ -136,11 +136,11 @@ void lv_calendar_set_day_names(lv_obj_t * calendar, const char ** day_names);
 /**
  * Set the name of the month
  * @param calendar pointer to a calendar object
- * @param day_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
+ * @param month_names pointer to an array with the names. E.g. `const char * days[12] = {"Jan", "Feb",
  * ...}` Only the pointer will be saved so this variable can't be local which will be destroyed
  * later.
  */
-void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** day_names);
+void lv_calendar_set_month_names(lv_obj_t * calendar, const char ** month_names);
 
 /**
  * Set a style of a calendar.

src/lv_objx/lv_canvas.c

@@ -113,6 +113,9 @@ lv_obj_t * lv_canvas_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_canvas_set_buffer(lv_obj_t * canvas, void * buf, lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(buf);
+
     lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
 
     ext->dsc.header.cf = cf;
@@ -133,6 +136,8 @@ void lv_canvas_set_buffer(lv_obj_t * canvas, void * buf, lv_coord_t w, lv_coord_
  */
 void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
 
     lv_img_buf_set_px_color(&ext->dsc, x, y, c);
@@ -151,6 +156,8 @@ void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t
  */
 void lv_canvas_set_palette(lv_obj_t * canvas, uint8_t id, lv_color_t c)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
 
     lv_img_buf_set_palette(&ext->dsc, id, c);
@@ -165,6 +172,8 @@ void lv_canvas_set_palette(lv_obj_t * canvas, uint8_t id, lv_color_t c)
  */
 void lv_canvas_set_style(lv_obj_t * canvas, lv_canvas_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     switch(type) {
         case LV_CANVAS_STYLE_MAIN: lv_img_set_style(canvas, LV_IMG_STYLE_MAIN, style); break;
     }
@@ -183,6 +192,8 @@ void lv_canvas_set_style(lv_obj_t * canvas, lv_canvas_style_t type, const lv_sty
  */
 lv_color_t lv_canvas_get_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     lv_canvas_ext_t * ext    = lv_obj_get_ext_attr(canvas);
     const lv_style_t * style = lv_canvas_get_style(canvas, LV_CANVAS_STYLE_MAIN);
 
@@ -196,6 +207,8 @@ lv_color_t lv_canvas_get_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y)
  */
 lv_img_dsc_t * lv_canvas_get_img(lv_obj_t * canvas)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
 
     return &ext->dsc;
@@ -209,6 +222,8 @@ lv_img_dsc_t * lv_canvas_get_img(lv_obj_t * canvas)
  */
 const lv_style_t * lv_canvas_get_style(const lv_obj_t * canvas, lv_canvas_style_t type)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
 
     switch(type) {
@@ -235,6 +250,9 @@ const lv_style_t * lv_canvas_get_style(const lv_obj_t * canvas, lv_canvas_style_
  */
 void lv_canvas_copy_buf(lv_obj_t * canvas, const void * to_copy, lv_coord_t x, lv_coord_t y, lv_coord_t w, lv_coord_t h)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(to_copy);
+
     lv_canvas_ext_t * ext = lv_obj_get_ext_attr(canvas);
     if(x + w >= ext->dsc.header.w || y + h >= ext->dsc.header.h) {
         LV_LOG_WARN("lv_canvas_copy_buf: x or y out of the canvas");
@@ -268,6 +286,9 @@ void lv_canvas_copy_buf(lv_obj_t * canvas, const void * to_copy, lv_coord_t x, l
 void lv_canvas_rotate(lv_obj_t * canvas, lv_img_dsc_t * img, int16_t angle, lv_coord_t offset_x, lv_coord_t offset_y,
                       int32_t pivot_x, int32_t pivot_y)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(img);
+
     lv_canvas_ext_t * ext_dst = lv_obj_get_ext_attr(canvas);
     const lv_style_t * style  = lv_canvas_get_style(canvas, LV_CANVAS_STYLE_MAIN);
     int32_t sinma             = lv_trigo_sin(-angle);
@@ -432,6 +453,8 @@ void lv_canvas_rotate(lv_obj_t * canvas, lv_img_dsc_t * img, int16_t angle, lv_c
  */
 void lv_canvas_fill_bg(lv_obj_t * canvas, lv_color_t color)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     uint32_t x = dsc->header.w * dsc->header.h;
@@ -455,6 +478,9 @@ void lv_canvas_fill_bg(lv_obj_t * canvas, lv_color_t color)
 void lv_canvas_draw_rect(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_t w, lv_coord_t h,
                          const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -516,6 +542,9 @@ void lv_canvas_draw_rect(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord
 void lv_canvas_draw_text(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_t max_w, const lv_style_t * style,
                          const char * txt, lv_label_align_t align)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -570,6 +599,9 @@ void lv_canvas_draw_text(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord
  */
 void lv_canvas_draw_img(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, const void * src, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -623,6 +655,9 @@ void lv_canvas_draw_img(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, const voi
  */
 void lv_canvas_draw_line(lv_obj_t * canvas, const lv_point_t * points, uint32_t point_cnt, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -677,6 +712,9 @@ void lv_canvas_draw_line(lv_obj_t * canvas, const lv_point_t * points, uint32_t
  */
 void lv_canvas_draw_polygon(lv_obj_t * canvas, const lv_point_t * points, uint32_t point_cnt, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -732,6 +770,9 @@ void lv_canvas_draw_polygon(lv_obj_t * canvas, const lv_point_t * points, uint32
 void lv_canvas_draw_arc(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_t r, int32_t start_angle,
                         int32_t end_angle, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
+    LV_ASSERT_NULL(style);
+
     lv_img_dsc_t * dsc = lv_canvas_get_img(canvas);
 
     /* Create a dummy display to fool the lv_draw function.
@@ -792,7 +833,7 @@ static lv_res_t lv_canvas_signal(lv_obj_t * canvas, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(canvas, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(canvas, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_cb.c

@@ -128,6 +128,8 @@ lv_obj_t * lv_cb_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_cb_set_text(lv_obj_t * cb, const char * txt)
 {
+    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
+
     lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
     lv_label_set_text(ext->label, txt);
 }
@@ -140,6 +142,8 @@ void lv_cb_set_text(lv_obj_t * cb, const char * txt)
  */
 void lv_cb_set_static_text(lv_obj_t * cb, const char * txt)
 {
+    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
+
     lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
     lv_label_set_static_text(ext->label, txt);
 }
@@ -152,6 +156,8 @@ void lv_cb_set_static_text(lv_obj_t * cb, const char * txt)
  *  */
 void lv_cb_set_style(lv_obj_t * cb, lv_cb_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
+
     lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
 
     switch(type) {
@@ -181,6 +187,8 @@ void lv_cb_set_style(lv_obj_t * cb, lv_cb_style_t type, const lv_style_t * style
  */
 const char * lv_cb_get_text(const lv_obj_t * cb)
 {
+    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
+
     lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
     return lv_label_get_text(ext->label);
 }
@@ -193,6 +201,8 @@ const char * lv_cb_get_text(const lv_obj_t * cb)
  *  */
 const lv_style_t * lv_cb_get_style(const lv_obj_t * cb, lv_cb_style_t type)
 {
+    LV_ASSERT_OBJ(cb, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_cb_ext_t * ext        = lv_obj_get_ext_attr(cb);
 
@@ -302,7 +312,7 @@ static lv_res_t lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(cb, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(cb, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
 

src/lv_objx/lv_chart.c

@@ -175,6 +175,8 @@ lv_obj_t * lv_chart_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 lv_chart_series_t * lv_chart_add_series(lv_obj_t * chart, lv_color_t color)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext    = lv_obj_get_ext_attr(chart);
     lv_chart_series_t * ser = lv_ll_ins_head(&ext->series_ll);
     LV_ASSERT_MEM(ser);
@@ -214,6 +216,9 @@ lv_chart_series_t * lv_chart_add_series(lv_obj_t * chart, lv_color_t color)
  */
 void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * serie)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(serie);
+
     if(chart == NULL || serie == NULL) return;
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext == NULL) return;
@@ -238,6 +243,8 @@ void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * serie)
  */
 void lv_chart_set_div_line_count(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->hdiv_cnt == hdiv && ext->vdiv_cnt == vdiv) return;
 
@@ -255,6 +262,8 @@ void lv_chart_set_div_line_count(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv)
  */
 void lv_chart_set_range(lv_obj_t * chart, lv_coord_t ymin, lv_coord_t ymax)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->ymin == ymin && ext->ymax == ymax) return;
 
@@ -271,6 +280,8 @@ void lv_chart_set_range(lv_obj_t * chart, lv_coord_t ymin, lv_coord_t ymax)
  */
 void lv_chart_set_type(lv_obj_t * chart, lv_chart_type_t type)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->type == type) return;
 
@@ -286,6 +297,8 @@ void lv_chart_set_type(lv_obj_t * chart, lv_chart_type_t type)
  */
 void lv_chart_set_point_count(lv_obj_t * chart, uint16_t point_cnt)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->point_cnt == point_cnt) return;
 
@@ -348,6 +361,8 @@ void lv_chart_set_point_count(lv_obj_t * chart, uint16_t point_cnt)
  */
 void lv_chart_set_series_opa(lv_obj_t * chart, lv_opa_t opa)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->series.opa == opa) return;
 
@@ -362,6 +377,8 @@ void lv_chart_set_series_opa(lv_obj_t * chart, lv_opa_t opa)
  */
 void lv_chart_set_series_width(lv_obj_t * chart, lv_coord_t width)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->series.width == width) return;
 
@@ -375,6 +392,8 @@ void lv_chart_set_series_width(lv_obj_t * chart, lv_coord_t width)
  */
 void lv_chart_set_series_darking(lv_obj_t * chart, lv_opa_t dark_eff)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->series.dark == dark_eff) return;
 
@@ -390,6 +409,9 @@ void lv_chart_set_series_darking(lv_obj_t * chart, lv_opa_t dark_eff)
  */
 void lv_chart_init_points(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t y)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     uint16_t i;
     for(i = 0; i < ext->point_cnt; i++) {
@@ -407,6 +429,9 @@ void lv_chart_init_points(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t
  */
 void lv_chart_set_points(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t y_array[])
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     memcpy(ser->points, y_array, ext->point_cnt * (sizeof(lv_coord_t)));
     ser->start_point = 0;
@@ -421,6 +446,9 @@ void lv_chart_set_points(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t y
  */
 void lv_chart_set_next(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t y)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->update_mode == LV_CHART_UPDATE_MODE_SHIFT) {
         ser->points[ser->start_point] =
@@ -447,6 +475,8 @@ void lv_chart_set_next(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t y)
  */
 void lv_chart_set_update_mode(lv_obj_t * chart, lv_chart_update_mode_t update_mode)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     if(ext->update_mode == update_mode) return;
 
@@ -464,6 +494,8 @@ void lv_chart_set_update_mode(lv_obj_t * chart, lv_chart_update_mode_t update_mo
  */
 void lv_chart_set_x_tick_length(lv_obj_t * chart, uint8_t major_tick_len, uint8_t minor_tick_len)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->x_axis.major_tick_len = major_tick_len;
     ext->x_axis.minor_tick_len = minor_tick_len;
@@ -479,6 +511,8 @@ void lv_chart_set_x_tick_length(lv_obj_t * chart, uint8_t major_tick_len, uint8_
  */
 void lv_chart_set_y_tick_length(lv_obj_t * chart, uint8_t major_tick_len, uint8_t minor_tick_len)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->y_axis.major_tick_len = major_tick_len;
     ext->y_axis.minor_tick_len = minor_tick_len;
@@ -494,6 +528,8 @@ void lv_chart_set_y_tick_length(lv_obj_t * chart, uint8_t major_tick_len, uint8_
  */
 void lv_chart_set_secondary_y_tick_length(lv_obj_t * chart, uint8_t major_tick_len, uint8_t minor_tick_len)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->secondary_y_axis.major_tick_len = major_tick_len;
     ext->secondary_y_axis.minor_tick_len = minor_tick_len;
@@ -510,6 +546,9 @@ void lv_chart_set_secondary_y_tick_length(lv_obj_t * chart, uint8_t major_tick_l
 void lv_chart_set_x_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                                lv_chart_axis_options_t options)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(list_of_values);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->x_axis.num_tick_marks = num_tick_marks;
     ext->x_axis.list_of_values = list_of_values;
@@ -527,6 +566,9 @@ void lv_chart_set_x_tick_texts(lv_obj_t * chart, const char * list_of_values, ui
 void lv_chart_set_y_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                                lv_chart_axis_options_t options)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(list_of_values);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->y_axis.num_tick_marks = num_tick_marks;
     ext->y_axis.list_of_values = list_of_values;
@@ -544,6 +586,9 @@ void lv_chart_set_y_tick_texts(lv_obj_t * chart, const char * list_of_values, ui
 void lv_chart_set_secondary_y_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                                         lv_chart_axis_options_t options)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(list_of_values);
+
     lv_chart_ext_t * ext       = lv_obj_get_ext_attr(chart);
     ext->secondary_y_axis.num_tick_marks = num_tick_marks;
     ext->secondary_y_axis.list_of_values = list_of_values;
@@ -557,6 +602,8 @@ void lv_chart_set_secondary_y_tick_texts(lv_obj_t * chart, const char * list_of_
  */
 void lv_chart_set_margin(lv_obj_t * chart, uint16_t margin)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     ext->margin          = margin;
     lv_obj_refresh_ext_draw_pad(chart);
@@ -573,6 +620,8 @@ void lv_chart_set_margin(lv_obj_t * chart, uint16_t margin)
  */
 lv_chart_type_t lv_chart_get_type(const lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->type;
 }
@@ -584,6 +633,8 @@ lv_chart_type_t lv_chart_get_type(const lv_obj_t * chart)
  */
 uint16_t lv_chart_get_point_cnt(const lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->point_cnt;
 }
@@ -595,6 +646,8 @@ uint16_t lv_chart_get_point_cnt(const lv_obj_t * chart)
  */
 lv_opa_t lv_chart_get_series_opa(const lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->series.opa;
 }
@@ -606,6 +659,8 @@ lv_opa_t lv_chart_get_series_opa(const lv_obj_t * chart)
  */
 lv_coord_t lv_chart_get_series_width(const lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->series.width;
 }
@@ -617,6 +672,8 @@ lv_coord_t lv_chart_get_series_width(const lv_obj_t * chart)
  */
 lv_opa_t lv_chart_get_series_darking(const lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->series.dark;
 }
@@ -631,6 +688,8 @@ lv_opa_t lv_chart_get_series_darking(const lv_obj_t * chart)
  */
 void lv_chart_refresh(lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_obj_invalidate(chart);
 }
 
@@ -641,6 +700,8 @@ void lv_chart_refresh(lv_obj_t * chart)
  */
 uint16_t lv_chart_get_margin(lv_obj_t * chart)
 {
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
     return ext->margin;
 }
@@ -704,7 +765,7 @@ static lv_res_t lv_chart_signal(lv_obj_t * chart, lv_signal_t sign, void * param
     lv_res_t res;
     res = ancestor_signal(chart, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(chart, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
 

src/lv_objx/lv_cont.c

@@ -128,6 +128,8 @@ lv_obj_t * lv_cont_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     if(ext->layout == layout) return;
 
@@ -148,6 +150,8 @@ void lv_cont_set_layout(lv_obj_t * cont, lv_layout_t layout)
  */
 void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t top, lv_fit_t bottom)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_obj_invalidate(cont);
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     if(ext->fit_left == left && ext->fit_right == right && ext->fit_top == top && ext->fit_bottom == bottom) {
@@ -174,6 +178,8 @@ void lv_cont_set_fit4(lv_obj_t * cont, lv_fit_t left, lv_fit_t right, lv_fit_t t
  */
 lv_layout_t lv_cont_get_layout(const lv_obj_t * cont)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     return ext->layout;
 }
@@ -185,6 +191,8 @@ lv_layout_t lv_cont_get_layout(const lv_obj_t * cont)
  */
 lv_fit_t lv_cont_get_fit_left(const lv_obj_t * cont)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     return ext->fit_left;
 }
@@ -196,6 +204,8 @@ lv_fit_t lv_cont_get_fit_left(const lv_obj_t * cont)
  */
 lv_fit_t lv_cont_get_fit_right(const lv_obj_t * cont)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     return ext->fit_right;
 }
@@ -207,6 +217,8 @@ lv_fit_t lv_cont_get_fit_right(const lv_obj_t * cont)
  */
 lv_fit_t lv_cont_get_fit_top(const lv_obj_t * cont)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     return ext->fit_top;
 }
@@ -218,6 +230,8 @@ lv_fit_t lv_cont_get_fit_top(const lv_obj_t * cont)
  */
 lv_fit_t lv_cont_get_fit_bottom(const lv_obj_t * cont)
 {
+    LV_ASSERT_OBJ(cont, LV_OBJX_NAME);
+
     lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
     return ext->fit_bottom;
 }
@@ -240,7 +254,7 @@ static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(cont, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(cont, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_STYLE_CHG) { /*Recalculate the padding if the style changed*/
         lv_cont_refr_layout(cont);

src/lv_objx/lv_ddlist.c

@@ -167,6 +167,9 @@ lv_obj_t * lv_ddlist_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_ddlist_set_options(lv_obj_t * ddlist, const char * options)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+    LV_ASSERT_STR(options);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     /*Count the '\n'-s to determine the number of options*/
@@ -199,6 +202,8 @@ void lv_ddlist_set_options(lv_obj_t * ddlist, const char * options)
  */
 void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
     if(ext->sel_opt_id == sel_opt) return;
 
@@ -220,6 +225,8 @@ void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
  */
 void lv_ddlist_set_fix_height(lv_obj_t * ddlist, lv_coord_t h)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
     if(ext->fix_height == h) return;
 
@@ -235,6 +242,8 @@ void lv_ddlist_set_fix_height(lv_obj_t * ddlist, lv_coord_t h)
  */
 void lv_ddlist_set_fix_width(lv_obj_t * ddlist, lv_coord_t w)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
     if(w == 0) {
         lv_cont_set_fit2(ddlist, LV_FIT_TIGHT, lv_cont_get_fit_bottom(ddlist));
@@ -259,6 +268,8 @@ void lv_ddlist_set_fix_width(lv_obj_t * ddlist, lv_coord_t w)
  */
 void lv_ddlist_set_draw_arrow(lv_obj_t * ddlist, bool en)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     /*Set the flag*/
@@ -272,6 +283,8 @@ void lv_ddlist_set_draw_arrow(lv_obj_t * ddlist, bool en)
  */
 void lv_ddlist_set_stay_open(lv_obj_t * ddlist, bool en)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     /*Set the flag*/
@@ -286,6 +299,8 @@ void lv_ddlist_set_stay_open(lv_obj_t * ddlist, bool en)
  */
 void lv_ddlist_set_style(lv_obj_t * ddlist, lv_ddlist_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     switch(type) {
@@ -304,6 +319,8 @@ void lv_ddlist_set_style(lv_obj_t * ddlist, lv_ddlist_style_t type, const lv_sty
 
 void lv_ddlist_set_align(lv_obj_t * ddlist, lv_label_align_t align)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     lv_label_set_align(ext->label, align);
@@ -324,6 +341,8 @@ void lv_ddlist_set_align(lv_obj_t * ddlist, lv_label_align_t align)
  */
 const char * lv_ddlist_get_options(const lv_obj_t * ddlist)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
     return lv_label_get_text(ext->label);
 }
@@ -335,6 +354,8 @@ const char * lv_ddlist_get_options(const lv_obj_t * ddlist)
  */
 uint16_t lv_ddlist_get_selected(const lv_obj_t * ddlist)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     return ext->sel_opt_id;
@@ -348,6 +369,8 @@ uint16_t lv_ddlist_get_selected(const lv_obj_t * ddlist)
  */
 void lv_ddlist_get_selected_str(const lv_obj_t * ddlist, char * buf, uint16_t buf_size)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     uint16_t i;
@@ -378,6 +401,8 @@ void lv_ddlist_get_selected_str(const lv_obj_t * ddlist, char * buf, uint16_t bu
  */
 lv_coord_t lv_ddlist_get_fix_height(const lv_obj_t * ddlist)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
     return ext->fix_height;
 }
@@ -388,6 +413,8 @@ lv_coord_t lv_ddlist_get_fix_height(const lv_obj_t * ddlist)
  */
 bool lv_ddlist_get_draw_arrow(lv_obj_t * ddlist)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     return ext->draw_arrow ? true : false;
@@ -399,6 +426,8 @@ bool lv_ddlist_get_draw_arrow(lv_obj_t * ddlist)
  */
 bool lv_ddlist_get_stay_open(lv_obj_t * ddlist)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     return ext->stay_open ? true : false;
@@ -412,6 +441,8 @@ bool lv_ddlist_get_stay_open(lv_obj_t * ddlist)
  */
 const lv_style_t * lv_ddlist_get_style(const lv_obj_t * ddlist, lv_ddlist_style_t type)
 {
+    LV_ASSERT_OBJ(ddlist, LV_OBJX_NAME);
+
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 
     switch(type) {
@@ -625,7 +656,7 @@ static lv_res_t lv_ddlist_signal(lv_obj_t * ddlist, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(ddlist, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(ddlist, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
 

src/lv_objx/lv_gauge.c

@@ -134,6 +134,9 @@ lv_obj_t * lv_gauge_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_gauge_set_needle_count(lv_obj_t * gauge, uint8_t needle_cnt, const lv_color_t colors[])
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+    LV_ASSERT_NULL(colors);
+
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
 
     if(ext->needle_count != needle_cnt) {
@@ -167,6 +170,8 @@ void lv_gauge_set_needle_count(lv_obj_t * gauge, uint8_t needle_cnt, const lv_co
  */
 void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle_id, int16_t value)
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
 
     if(needle_id >= ext->needle_count) return;
@@ -196,6 +201,8 @@ void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle_id, int16_t value)
  */
 void lv_gauge_set_scale(lv_obj_t * gauge, uint16_t angle, uint8_t line_cnt, uint8_t label_cnt)
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+
     lv_lmeter_set_scale(gauge, angle, line_cnt);
 
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
@@ -215,6 +222,8 @@ void lv_gauge_set_scale(lv_obj_t * gauge, uint16_t angle, uint8_t line_cnt, uint
  */
 int16_t lv_gauge_get_value(const lv_obj_t * gauge, uint8_t needle)
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
     int16_t min          = lv_gauge_get_min_value(gauge);
 
@@ -230,6 +239,8 @@ int16_t lv_gauge_get_value(const lv_obj_t * gauge, uint8_t needle)
  */
 uint8_t lv_gauge_get_needle_count(const lv_obj_t * gauge)
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
     return ext->needle_count;
 }
@@ -241,6 +252,8 @@ uint8_t lv_gauge_get_needle_count(const lv_obj_t * gauge)
  */
 uint8_t lv_gauge_get_label_count(const lv_obj_t * gauge)
 {
+    LV_ASSERT_OBJ(gauge, LV_OBJX_NAME);
+
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
     return ext->label_count;
 }
@@ -261,7 +274,6 @@ uint8_t lv_gauge_get_label_count(const lv_obj_t * gauge)
  */
 static bool lv_gauge_design(lv_obj_t * gauge, const lv_area_t * mask, lv_design_mode_t mode)
 {
-
     /*Return false if the object is not covers the mask_p area*/
     if(mode == LV_DESIGN_COVER_CHK) {
         return false;
@@ -320,7 +332,7 @@ static lv_res_t lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param
     /* Include the ancient signal function */
     res = ancestor_signal(gauge, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(gauge, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
     if(sign == LV_SIGNAL_CLEANUP) {

src/lv_objx/lv_img.c

@@ -123,6 +123,8 @@ lv_obj_t * lv_img_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_img_set_src(lv_obj_t * img, const void * src_img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_src_t src_type = lv_img_src_get_type(src_img);
     lv_img_ext_t * ext    = lv_obj_get_ext_attr(img);
 
@@ -203,6 +205,8 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img)
  */
 void lv_img_set_auto_size(lv_obj_t * img, bool en)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     ext->auto_size = (en == false ? 0 : 1);
@@ -216,6 +220,8 @@ void lv_img_set_auto_size(lv_obj_t * img, bool en)
  */
 void lv_img_set_offset_x(lv_obj_t * img, lv_coord_t x)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     if(x < ext->w - 1) {
@@ -232,6 +238,8 @@ void lv_img_set_offset_x(lv_obj_t * img, lv_coord_t x)
  */
 void lv_img_set_offset_y(lv_obj_t * img, lv_coord_t y)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     if(y < ext->h - 1) {
@@ -251,6 +259,8 @@ void lv_img_set_offset_y(lv_obj_t * img, lv_coord_t y)
  */
 const void * lv_img_get_src(lv_obj_t * img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     return ext->src;
@@ -263,6 +273,8 @@ const void * lv_img_get_src(lv_obj_t * img)
  */
 const char * lv_img_get_file_name(const lv_obj_t * img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     if(ext->src_type == LV_IMG_SRC_FILE)
@@ -278,6 +290,8 @@ const char * lv_img_get_file_name(const lv_obj_t * img)
  */
 bool lv_img_get_auto_size(const lv_obj_t * img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     return ext->auto_size == 0 ? false : true;
@@ -290,6 +304,8 @@ bool lv_img_get_auto_size(const lv_obj_t * img)
  */
 lv_coord_t lv_img_get_offset_x(lv_obj_t * img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     return ext->offset.x;
@@ -302,6 +318,8 @@ lv_coord_t lv_img_get_offset_x(lv_obj_t * img)
  */
 lv_coord_t lv_img_get_offset_y(lv_obj_t * img)
 {
+    LV_ASSERT_OBJ(img, LV_OBJX_NAME);
+
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
 
     return ext->offset.y;
@@ -387,7 +405,7 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
     res = ancestor_signal(img, sign, param);
     if(res != LV_RES_OK) return res;
 
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(img, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_img_ext_t * ext = lv_obj_get_ext_attr(img);
     if(sign == LV_SIGNAL_CLEANUP) {

src/lv_objx/lv_imgbtn.c

@@ -116,6 +116,8 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     ext->img_src[state] = src;
@@ -138,6 +140,8 @@ void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src
 void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src_left, const void * src_mid,
                        const void * src_right)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     ext->img_src_left[state] = src_left;
@@ -157,6 +161,8 @@ void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_btn_state_t state, const void * src
  */
 void lv_imgbtn_set_style(lv_obj_t * imgbtn, lv_imgbtn_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_btn_set_style(imgbtn, type, style);
 }
 
@@ -173,6 +179,8 @@ void lv_imgbtn_set_style(lv_obj_t * imgbtn, lv_imgbtn_style_t type, const lv_sty
  */
 const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     return ext->img_src[state];
@@ -187,6 +195,8 @@ const void * lv_imgbtn_get_src(lv_obj_t * imgbtn, lv_btn_state_t state)
  */
 const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     return ext->img_src_left[state];
@@ -200,6 +210,8 @@ const void * lv_imgbtn_get_src_left(lv_obj_t * imgbtn, lv_btn_state_t state)
  */
 const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     return ext->img_src_mid[state];
@@ -213,6 +225,8 @@ const void * lv_imgbtn_get_src_middle(lv_obj_t * imgbtn, lv_btn_state_t state)
  */
 const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_btn_state_t state)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     lv_imgbtn_ext_t * ext = lv_obj_get_ext_attr(imgbtn);
 
     return ext->img_src_right[state];
@@ -228,6 +242,8 @@ const void * lv_imgbtn_get_src_right(lv_obj_t * imgbtn, lv_btn_state_t state)
  */
 const lv_style_t * lv_imgbtn_get_style(const lv_obj_t * imgbtn, lv_imgbtn_style_t type)
 {
+    LV_ASSERT_OBJ(imgbtn, LV_OBJX_NAME);
+
     return lv_btn_get_style(imgbtn, type);
 }
 
@@ -347,7 +363,7 @@ static lv_res_t lv_imgbtn_signal(lv_obj_t * imgbtn, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(imgbtn, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(imgbtn, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_STYLE_CHG) {
         /* If the style changed then the button was clicked, released etc. so probably the state was

src/lv_objx/lv_kb.c

@@ -173,6 +173,9 @@ lv_obj_t * lv_kb_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_kb_set_ta(lv_obj_t * kb, lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+    if(ta) LV_ASSERT_OBJ(ta, "lv_ta");
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     lv_cursor_type_t cur_type;
 
@@ -198,6 +201,8 @@ void lv_kb_set_ta(lv_obj_t * kb, lv_obj_t * ta)
  */
 void lv_kb_set_mode(lv_obj_t * kb, lv_kb_mode_t mode)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     if(ext->mode == mode) return;
 
@@ -218,6 +223,8 @@ void lv_kb_set_mode(lv_obj_t * kb, lv_kb_mode_t mode)
  */
 void lv_kb_set_cursor_manage(lv_obj_t * kb, bool en)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     if(ext->cursor_mng == en) return;
 
@@ -243,6 +250,8 @@ void lv_kb_set_cursor_manage(lv_obj_t * kb, bool en)
  */
 void lv_kb_set_style(lv_obj_t * kb, lv_kb_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     switch(type) {
         case LV_KB_STYLE_BG: lv_btnm_set_style(kb, LV_BTNM_STYLE_BG, style); break;
         case LV_KB_STYLE_BTN_REL: lv_btnm_set_style(kb, LV_BTNM_STYLE_BTN_REL, style); break;
@@ -264,6 +273,8 @@ void lv_kb_set_style(lv_obj_t * kb, lv_kb_style_t type, const lv_style_t * style
  */
 lv_obj_t * lv_kb_get_ta(const lv_obj_t * kb)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     return ext->ta;
 }
@@ -275,6 +286,8 @@ lv_obj_t * lv_kb_get_ta(const lv_obj_t * kb)
  */
 lv_kb_mode_t lv_kb_get_mode(const lv_obj_t * kb)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     return ext->mode;
 }
@@ -286,6 +299,8 @@ lv_kb_mode_t lv_kb_get_mode(const lv_obj_t * kb)
  */
 bool lv_kb_get_cursor_manage(const lv_obj_t * kb)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
     return ext->cursor_mng == 0 ? false : true;
 }
@@ -298,6 +313,8 @@ bool lv_kb_get_cursor_manage(const lv_obj_t * kb)
  */
 const lv_style_t * lv_kb_get_style(const lv_obj_t * kb, lv_kb_style_t type)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
 
     switch(type) {
@@ -326,6 +343,8 @@ const lv_style_t * lv_kb_get_style(const lv_obj_t * kb, lv_kb_style_t type)
  */
 void lv_kb_def_event_cb(lv_obj_t * kb, lv_event_t event)
 {
+    LV_ASSERT_OBJ(kb, LV_OBJX_NAME);
+
     if(event != LV_EVENT_VALUE_CHANGED) return;
 
     lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
@@ -422,7 +441,7 @@ static lv_res_t lv_kb_signal(lv_obj_t * kb, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(kb, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(kb, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_label.c

@@ -1024,7 +1024,7 @@ static lv_res_t lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param
     /* Include the ancient signal function */
     res = ancestor_signal(label, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(label, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
     if(sign == LV_SIGNAL_CLEANUP) {

src/lv_objx/lv_led.c

@@ -112,6 +112,8 @@ lv_obj_t * lv_led_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_led_set_bright(lv_obj_t * led, uint8_t bright)
 {
+    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
+
     /*Set the brightness*/
     lv_led_ext_t * ext = lv_obj_get_ext_attr(led);
     if(ext->bright == bright) return;
@@ -128,6 +130,8 @@ void lv_led_set_bright(lv_obj_t * led, uint8_t bright)
  */
 void lv_led_on(lv_obj_t * led)
 {
+    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
+
     lv_led_set_bright(led, LV_LED_BRIGHT_ON);
 }
 
@@ -137,6 +141,8 @@ void lv_led_on(lv_obj_t * led)
  */
 void lv_led_off(lv_obj_t * led)
 {
+    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
+
     lv_led_set_bright(led, LV_LED_BRIGHT_OFF);
 }
 
@@ -146,6 +152,8 @@ void lv_led_off(lv_obj_t * led)
  */
 void lv_led_toggle(lv_obj_t * led)
 {
+    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
+
     uint8_t bright = lv_led_get_bright(led);
     if(bright > (LV_LED_BRIGHT_OFF + LV_LED_BRIGHT_ON) >> 1)
         lv_led_off(led);
@@ -164,6 +172,8 @@ void lv_led_toggle(lv_obj_t * led)
  */
 uint8_t lv_led_get_bright(const lv_obj_t * led)
 {
+    LV_ASSERT_OBJ(led, LV_OBJX_NAME);
+
     lv_led_ext_t * ext = lv_obj_get_ext_attr(led);
     return ext->bright;
 }

src/lv_objx/lv_line.c

@@ -109,6 +109,8 @@ lv_obj_t * lv_line_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_line_set_points(lv_obj_t * line, const lv_point_t point_a[], uint16_t point_num)
 {
+    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
+
     lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
     ext->point_array    = point_a;
     ext->point_num      = point_num;
@@ -137,6 +139,8 @@ void lv_line_set_points(lv_obj_t * line, const lv_point_t point_a[], uint16_t po
  */
 void lv_line_set_auto_size(lv_obj_t * line, bool en)
 {
+    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
+
     lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
     if(ext->auto_size == en) return;
 
@@ -155,6 +159,8 @@ void lv_line_set_auto_size(lv_obj_t * line, bool en)
  */
 void lv_line_set_y_invert(lv_obj_t * line, bool en)
 {
+    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
+
     lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
     if(ext->y_inv == en) return;
 
@@ -174,6 +180,8 @@ void lv_line_set_y_invert(lv_obj_t * line, bool en)
  */
 bool lv_line_get_auto_size(const lv_obj_t * line)
 {
+    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
+
     lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
 
     return ext->auto_size == 0 ? false : true;
@@ -186,6 +194,8 @@ bool lv_line_get_auto_size(const lv_obj_t * line)
  */
 bool lv_line_get_y_invert(const lv_obj_t * line)
 {
+    LV_ASSERT_OBJ(line, LV_OBJX_NAME);
+
     lv_line_ext_t * ext = lv_obj_get_ext_attr(line);
 
     return ext->y_inv == 0 ? false : true;
@@ -284,7 +294,7 @@ static lv_res_t lv_line_signal(lv_obj_t * line, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(line, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(line, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
    if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         const lv_style_t * style = lv_line_get_style(line, LV_LINE_STYLE_MAIN);

src/lv_objx/lv_list.c

@@ -152,13 +152,15 @@ lv_obj_t * lv_list_create(lv_obj_t * par, const lv_obj_t * copy)
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param list pointer to an object
  */
-void lv_list_clean(lv_obj_t * obj)
+void lv_list_clean(lv_obj_t * list)
 {
-    lv_obj_t * scrl = lv_page_get_scrl(obj);
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
+    lv_obj_t * scrl = lv_page_get_scrl(list);
     lv_obj_clean(scrl);
-    lv_list_ext_t * ext = lv_obj_get_ext_attr(obj);
+    lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
     ext->size           = 0;
 }
 
@@ -175,6 +177,8 @@ void lv_list_clean(lv_obj_t * obj)
  */
 lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * txt)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
     ext->size++;
     /*Create a list element with the image an the text*/
@@ -240,6 +244,8 @@ lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * t
  */
 bool lv_list_remove(const lv_obj_t * list, uint16_t index)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
     if(index >= ext->size) return false;
     uint16_t count = 0;
@@ -267,6 +273,8 @@ bool lv_list_remove(const lv_obj_t * list, uint16_t index)
  */
 void lv_list_set_single_mode(lv_obj_t * list, bool mode)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
 
     ext->single_mode = mode;
@@ -282,6 +290,9 @@ void lv_list_set_single_mode(lv_obj_t * list, bool mode)
  */
 void lv_list_set_btn_selected(lv_obj_t * list, lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+    if(btn) LV_ASSERT_OBJ(list, "lv_btn");
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
 
     if(ext->selected_btn) {
@@ -321,6 +332,8 @@ void lv_list_set_btn_selected(lv_obj_t * list, lv_obj_t * btn)
  */
 void lv_list_set_style(lv_obj_t * list, lv_list_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext           = lv_obj_get_ext_attr(list);
     lv_btn_style_t btn_style_refr = LV_BTN_STYLE_REL;
     lv_obj_t * btn;
@@ -373,6 +386,8 @@ void lv_list_set_style(lv_obj_t * list, lv_list_style_t type, const lv_style_t *
  */
  void lv_list_set_layout(lv_obj_t * list, lv_layout_t layout)
  {
+     LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
 	/* Update list layout if necessary */
 	if (layout == lv_list_get_layout(list)) return;
 
@@ -406,6 +421,8 @@ void lv_list_set_style(lv_obj_t * list, lv_list_style_t type, const lv_style_t *
  */
 bool lv_list_get_single_mode(lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
 
     return (ext->single_mode);
@@ -418,6 +435,8 @@ bool lv_list_get_single_mode(lv_obj_t * list)
  */
 const char * lv_list_get_btn_text(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, "lv_btn");
+
     lv_obj_t * label = lv_list_get_btn_label(btn);
     if(label == NULL) return "";
     return lv_label_get_text(label);
@@ -430,6 +449,8 @@ const char * lv_list_get_btn_text(const lv_obj_t * btn)
  */
 lv_obj_t * lv_list_get_btn_label(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, "lv_btn");
+
     lv_obj_t * label = lv_obj_get_child(btn, NULL);
     if(label == NULL) return NULL;
 
@@ -448,6 +469,8 @@ lv_obj_t * lv_list_get_btn_label(const lv_obj_t * btn)
  */
 lv_obj_t * lv_list_get_btn_img(const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(btn, "lv_btn");
+
 #if LV_USE_IMG != 0
     lv_obj_t * img = lv_obj_get_child(btn, NULL);
     if(img == NULL) return NULL;
@@ -471,6 +494,8 @@ lv_obj_t * lv_list_get_btn_img(const lv_obj_t * btn)
  */
 lv_obj_t * lv_list_get_prev_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     /* Not a good practice but user can add/create objects to the lists manually.
      * When getting the next button try to be sure that it is at least a button */
 
@@ -496,6 +521,8 @@ lv_obj_t * lv_list_get_prev_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
  */
 lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     /* Not a good practice but user can add/create objects to the lists manually.
      * When getting the next button try to be sure that it is at least a button */
 
@@ -521,6 +548,9 @@ lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
  */
 int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+    LV_ASSERT_OBJ(btn, "lv_btn");
+
     int index = 0;
     if(list == NULL) {
         /* no list provided, assuming btn is part of a list */
@@ -544,6 +574,8 @@ int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
  */
 uint16_t lv_list_get_size(const lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
     return ext->size;
 }
@@ -556,6 +588,8 @@ uint16_t lv_list_get_size(const lv_obj_t * list)
  */
 lv_obj_t * lv_list_get_btn_selected(const lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
     return ext->selected_btn;
 }
@@ -568,6 +602,8 @@ lv_obj_t * lv_list_get_btn_selected(const lv_obj_t * list)
  */
 lv_layout_t lv_list_get_layout(lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     return lv_page_get_scrl_layout(list);
 }
 
@@ -579,6 +615,8 @@ lv_layout_t lv_list_get_layout(lv_obj_t * list)
  */
 const lv_style_t * lv_list_get_style(const lv_obj_t * list, lv_list_style_t type)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_list_ext_t * ext      = lv_obj_get_ext_attr(list);
 
@@ -608,6 +646,8 @@ const lv_style_t * lv_list_get_style(const lv_obj_t * list, lv_list_style_t type
  */
 void lv_list_up(const lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     /*Search the first list element which 'y' coordinate is below the parent
      * and position the list to show this element on the bottom*/
     lv_obj_t * scrl = lv_page_get_scrl(list);
@@ -653,6 +693,8 @@ void lv_list_up(const lv_obj_t * list)
  */
 void lv_list_down(const lv_obj_t * list)
 {
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     /*Search the first list element which 'y' coordinate is above the parent
      * and position the list to show this element on the top*/
     lv_obj_t * scrl = lv_page_get_scrl(list);
@@ -694,6 +736,7 @@ void lv_list_down(const lv_obj_t * list)
  */
 void lv_list_focus(const lv_obj_t * btn, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(btn, "");
 
 #if LV_USE_ANIMATION == 0
     anim = false;
@@ -722,7 +765,7 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_page_signal(list, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(list, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_PRESSING ||
        sign == LV_SIGNAL_LONG_PRESS || sign == LV_SIGNAL_LONG_PRESS_REP) {
@@ -870,7 +913,7 @@ static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * para
     /* Include the ancient signal function */
     res = ancestor_btn_signal(btn, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(btn, param, "");
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
     if(sign == LV_SIGNAL_RELEASED) {
         lv_obj_t * list          = lv_obj_get_parent(lv_obj_get_parent(btn));

src/lv_objx/lv_list.h

@@ -95,9 +95,9 @@ lv_obj_t * lv_list_create(lv_obj_t * par, const lv_obj_t * copy);
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param list pointer to an object
  */
-void lv_list_clean(lv_obj_t * obj);
+void lv_list_clean(lv_obj_t * list);
 
 /*======================
  * Add/remove functions

src/lv_objx/lv_lmeter.c

@@ -122,6 +122,8 @@ lv_obj_t * lv_lmeter_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_lmeter_set_value(lv_obj_t * lmeter, int16_t value)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     if(ext->cur_value == value) return;
 
@@ -138,6 +140,8 @@ void lv_lmeter_set_value(lv_obj_t * lmeter, int16_t value)
  */
 void lv_lmeter_set_range(lv_obj_t * lmeter, int16_t min, int16_t max)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     if(ext->min_value == min && ext->max_value == max) return;
 
@@ -162,6 +166,8 @@ void lv_lmeter_set_range(lv_obj_t * lmeter, int16_t min, int16_t max)
  */
 void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t line_cnt)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     if(ext->scale_angle == angle && ext->line_cnt == line_cnt) return;
 
@@ -182,6 +188,8 @@ void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t line_cnt)
  */
 int16_t lv_lmeter_get_value(const lv_obj_t * lmeter)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     return ext->cur_value;
 }
@@ -193,6 +201,8 @@ int16_t lv_lmeter_get_value(const lv_obj_t * lmeter)
  */
 int16_t lv_lmeter_get_min_value(const lv_obj_t * lmeter)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     return ext->min_value;
 }
@@ -204,6 +214,8 @@ int16_t lv_lmeter_get_min_value(const lv_obj_t * lmeter)
  */
 int16_t lv_lmeter_get_max_value(const lv_obj_t * lmeter)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     return ext->max_value;
 }
@@ -215,6 +227,8 @@ int16_t lv_lmeter_get_max_value(const lv_obj_t * lmeter)
  */
 uint8_t lv_lmeter_get_line_count(const lv_obj_t * lmeter)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     return ext->line_cnt;
 }
@@ -226,6 +240,8 @@ uint8_t lv_lmeter_get_line_count(const lv_obj_t * lmeter)
  */
 uint16_t lv_lmeter_get_scale_angle(const lv_obj_t * lmeter)
 {
+    LV_ASSERT_OBJ(lmeter, LV_OBJX_NAME);
+
     lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
     return ext->scale_angle;
 }
@@ -338,7 +354,7 @@ static lv_res_t lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(lmeter, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(lmeter, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_mbox.c

@@ -141,6 +141,9 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_mbox_add_btns(lv_obj_t * mbox, const char ** btn_map)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+    LV_ASSERT_NULL(btn_map);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
 
     /*Create a button matrix if not exists yet*/
@@ -176,6 +179,9 @@ void lv_mbox_add_btns(lv_obj_t * mbox, const char ** btn_map)
  */
 void lv_mbox_set_text(lv_obj_t * mbox, const char * txt)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+    LV_ASSERT_STR(txt);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     lv_label_set_text(ext->text, txt);
 
@@ -189,6 +195,8 @@ void lv_mbox_set_text(lv_obj_t * mbox, const char * txt)
  */
 void lv_mbox_set_anim_time(lv_obj_t * mbox, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     anim_time           = 0;
@@ -206,6 +214,8 @@ void lv_mbox_set_anim_time(lv_obj_t * mbox, uint16_t anim_time)
  */
 void lv_mbox_start_auto_close(lv_obj_t * mbox, uint16_t delay)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     if(lv_mbox_get_anim_time(mbox) != 0) {
         /*Add shrinking animations*/
@@ -260,6 +270,8 @@ void lv_mbox_start_auto_close(lv_obj_t * mbox, uint16_t delay)
  */
 void lv_mbox_stop_auto_close(lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_anim_del(mbox, NULL);
 #else
@@ -275,6 +287,8 @@ void lv_mbox_stop_auto_close(lv_obj_t * mbox)
  */
 void lv_mbox_set_style(lv_obj_t * mbox, lv_mbox_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
 
     switch(type) {
@@ -297,6 +311,8 @@ void lv_mbox_set_style(lv_obj_t * mbox, lv_mbox_style_t type, const lv_style_t *
  */
 void lv_mbox_set_recolor(lv_obj_t * mbox, bool en)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
 
     if(ext->btnm) lv_btnm_set_recolor(ext->btnm, en);
@@ -313,6 +329,8 @@ void lv_mbox_set_recolor(lv_obj_t * mbox, bool en)
  */
 const char * lv_mbox_get_text(const lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
 
     return lv_label_get_text(ext->text);
@@ -326,6 +344,8 @@ const char * lv_mbox_get_text(const lv_obj_t * mbox)
  */
 uint16_t lv_mbox_get_active_btn(lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     if(ext->btnm)
         return lv_btnm_get_active_btn(ext->btnm);
@@ -341,6 +361,8 @@ uint16_t lv_mbox_get_active_btn(lv_obj_t * mbox)
  */
 const char * lv_mbox_get_active_btn_text(lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     if(ext->btnm)
         return lv_btnm_get_active_btn_text(ext->btnm);
@@ -355,6 +377,8 @@ const char * lv_mbox_get_active_btn_text(lv_obj_t * mbox)
  */
 uint16_t lv_mbox_get_anim_time(const lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     return ext->anim_time;
@@ -372,6 +396,8 @@ uint16_t lv_mbox_get_anim_time(const lv_obj_t * mbox)
  */
 const lv_style_t * lv_mbox_get_style(const lv_obj_t * mbox, lv_mbox_style_t type)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_mbox_ext_t * ext      = lv_obj_get_ext_attr(mbox);
 
@@ -396,6 +422,8 @@ const lv_style_t * lv_mbox_get_style(const lv_obj_t * mbox, lv_mbox_style_t type
  */
 bool lv_mbox_get_recolor(const lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
 
     if(!ext->btnm) return false;
@@ -411,6 +439,8 @@ bool lv_mbox_get_recolor(const lv_obj_t * mbox)
  */
 lv_obj_t * lv_mbox_get_btnm(lv_obj_t * mbox)
 {
+    LV_ASSERT_OBJ(mbox, LV_OBJX_NAME);
+
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     return ext->btnm;
 }
@@ -443,7 +473,7 @@ static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(mbox, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(mbox, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
     if(sign == LV_SIGNAL_CORD_CHG) {

src/lv_objx/lv_objx_templ.c

@@ -120,6 +120,8 @@ lv_obj_t * lv_templ_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_templ_set_style(lv_obj_t * templ, lv_templ_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(templ, LV_OBJX_NAME);
+
     lv_templ_ext_t * ext = lv_obj_get_ext_attr(templ);
 
     switch(type) {
@@ -144,6 +146,8 @@ void lv_templ_set_style(lv_obj_t * templ, lv_templ_style_t type, const lv_style_
  */
 lv_style_t * lv_templ_get_style(const lv_obj_t * templ, lv_templ_style_t type)
 {
+    LV_ASSERT_OBJ(templ, LV_OBJX_NAME);
+
     lv_templ_ext_t * ext = lv_obj_get_ext_attr(templ);
     lv_style_t * style   = NULL;
 
@@ -209,7 +213,7 @@ static lv_res_t lv_templ_signal(lv_obj_t * templ, lv_signal_t sign, void * param
     /* Include the ancient signal function */
     res = ancestor_signal(templ, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(templ, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_page.c

@@ -174,11 +174,13 @@ lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy)
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param page pointer to an object
  */
-void lv_page_clean(lv_obj_t * obj)
+void lv_page_clean(lv_obj_t * page)
 {
-    lv_obj_t * scrl = lv_page_get_scrl(obj);
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
+    lv_obj_t * scrl = lv_page_get_scrl(page);
     lv_obj_clean(scrl);
 }
 
@@ -193,6 +195,8 @@ void lv_page_clean(lv_obj_t * obj)
  */
 void lv_page_set_sb_mode(lv_obj_t * page, lv_sb_mode_t sb_mode)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     if(ext->sb.mode == sb_mode) return;
 
@@ -219,6 +223,8 @@ void lv_page_set_sb_mode(lv_obj_t * page, lv_sb_mode_t sb_mode)
  */
 void lv_page_set_anim_time(lv_obj_t * page, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     ext->anim_time      = anim_time;
@@ -236,6 +242,8 @@ void lv_page_set_anim_time(lv_obj_t * page, uint16_t anim_time)
  */
 void lv_page_set_scroll_propagation(lv_obj_t * page, bool en)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     ext->scroll_prop    = en ? 1 : 0;
 }
@@ -247,6 +255,8 @@ void lv_page_set_scroll_propagation(lv_obj_t * page, bool en)
  */
 void lv_page_set_edge_flash(lv_obj_t * page, bool en)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_page_ext_t * ext     = lv_obj_get_ext_attr(page);
     ext->edge_flash.enabled = en ? 1 : 0;
@@ -264,6 +274,8 @@ void lv_page_set_edge_flash(lv_obj_t * page, bool en)
  *  */
 void lv_page_set_style(lv_obj_t * page, lv_page_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
 
     switch(type) {
@@ -294,6 +306,8 @@ void lv_page_set_style(lv_obj_t * page, lv_page_style_t type, const lv_style_t *
  */
 lv_obj_t * lv_page_get_scrl(const lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
 
     return ext->scrl;
@@ -306,6 +320,8 @@ lv_obj_t * lv_page_get_scrl(const lv_obj_t * page)
  */
 uint16_t lv_page_get_anim_time(const lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     return ext->anim_time;
@@ -322,6 +338,8 @@ uint16_t lv_page_get_anim_time(const lv_obj_t * page)
  */
 lv_sb_mode_t lv_page_get_sb_mode(const lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     return ext->sb.mode;
 }
@@ -333,6 +351,8 @@ lv_sb_mode_t lv_page_get_sb_mode(const lv_obj_t * page)
  */
 bool lv_page_get_scroll_propagation(lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     return ext->scroll_prop == 0 ? false : true;
 }
@@ -344,6 +364,8 @@ bool lv_page_get_scroll_propagation(lv_obj_t * page)
  */
 bool lv_page_get_edge_flash(lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     return ext->edge_flash.enabled == 0 ? false : true;
@@ -360,6 +382,8 @@ bool lv_page_get_edge_flash(lv_obj_t * page)
  */
 lv_coord_t lv_page_get_fit_width(lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     const lv_style_t * bg_style   = lv_page_get_style(page, LV_PAGE_STYLE_BG);
     const lv_style_t * scrl_style = lv_page_get_style(page, LV_PAGE_STYLE_SCRL);
 
@@ -374,6 +398,8 @@ lv_coord_t lv_page_get_fit_width(lv_obj_t * page)
  */
 lv_coord_t lv_page_get_fit_height(lv_obj_t * page)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     const lv_style_t * bg_style   = lv_page_get_style(page, LV_PAGE_STYLE_BG);
     const lv_style_t * scrl_style = lv_page_get_style(page, LV_PAGE_STYLE_SCRL);
 
@@ -389,6 +415,8 @@ lv_coord_t lv_page_get_fit_height(lv_obj_t * page)
  *  */
 const lv_style_t * lv_page_get_style(const lv_obj_t * page, lv_page_style_t type)
 {
+    LV_ASSERT_OBJ(page, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_page_ext_t * ext      = lv_obj_get_ext_attr(page);
 
@@ -795,7 +823,7 @@ static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(page, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(page, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
     lv_obj_t * child;
@@ -892,7 +920,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
     /* Include the ancient signal function */
     res = ancestor_signal(scrl, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(scrl, param, "");
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
     lv_obj_t * page               = lv_obj_get_parent(scrl);
     const lv_style_t * page_style = lv_obj_get_style(page);

src/lv_objx/lv_page.h

@@ -113,9 +113,9 @@ lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy);
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param page pointer to an object
  */
-void lv_page_clean(lv_obj_t * obj);
+void lv_page_clean(lv_obj_t * page);
 
 /**
  * Get the scrollable object of a page

src/lv_objx/lv_preload.c

@@ -132,6 +132,8 @@ lv_obj_t * lv_preload_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_preload_set_arc_length(lv_obj_t * preload, lv_anim_value_t deg)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
 
     ext->arc_length = deg;
@@ -144,6 +146,8 @@ void lv_preload_set_arc_length(lv_obj_t * preload, lv_anim_value_t deg)
  */
 void lv_preload_set_spin_time(lv_obj_t * preload, uint16_t time)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
 
     ext->time = time;
@@ -161,6 +165,8 @@ void lv_preload_set_spin_time(lv_obj_t * preload, uint16_t time)
  *  */
 void lv_preload_set_style(lv_obj_t * preload, lv_preload_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     switch(type) {
         case LV_PRELOAD_STYLE_MAIN: lv_arc_set_style(preload, LV_ARC_STYLE_MAIN, style); break;
     }
@@ -173,6 +179,8 @@ void lv_preload_set_style(lv_obj_t * preload, lv_preload_style_t type, const lv_
  *  */
 void lv_preload_set_type(lv_obj_t * preload, lv_preload_type_t type)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
 
     /*delete previous animation*/
@@ -255,6 +263,8 @@ void lv_preload_set_type(lv_obj_t * preload, lv_preload_type_t type)
 
 void lv_preload_set_dir(lv_obj_t * preload, lv_preload_dir_t dir)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
 
     ext->anim_dir = dir;
@@ -271,6 +281,8 @@ void lv_preload_set_dir(lv_obj_t * preload, lv_preload_dir_t dir)
  */
 lv_anim_value_t lv_preload_get_arc_length(const lv_obj_t * preload)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
     return ext->arc_length;
 }
@@ -281,6 +293,8 @@ lv_anim_value_t lv_preload_get_arc_length(const lv_obj_t * preload)
  */
 uint16_t lv_preload_get_spin_time(const lv_obj_t * preload)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
     return ext->time;
 }
@@ -293,6 +307,8 @@ uint16_t lv_preload_get_spin_time(const lv_obj_t * preload)
  *  */
 const lv_style_t * lv_preload_get_style(const lv_obj_t * preload, lv_preload_style_t type)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
 
     switch(type) {
@@ -310,6 +326,8 @@ const lv_style_t * lv_preload_get_style(const lv_obj_t * preload, lv_preload_sty
  *  */
 lv_preload_type_t lv_preload_get_type(lv_obj_t * preload)
 {
+    LV_ASSERT_OBJ(preload, LV_OBJX_NAME);
+
     lv_preload_ext_t * ext = lv_obj_get_ext_attr(preload);
     return ext->anim_type;
 }
@@ -414,7 +432,7 @@ static lv_res_t lv_preload_signal(lv_obj_t * preload, lv_signal_t sign, void * p
     /* Include the ancient signal function */
     res = ancestor_signal(preload, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(preload, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_roller.c

@@ -137,6 +137,9 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mode_t mode)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+    LV_ASSERT_STR(options);
+
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
 
     if(mode == LV_ROLLER_MODE_NORMAL) {
@@ -178,6 +181,8 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
  */
 void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
 
     lv_obj_t * label = ext->ddlist.label;
@@ -200,6 +205,8 @@ void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
  */
 void lv_roller_set_selected(lv_obj_t * roller, uint16_t sel_opt, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -217,6 +224,8 @@ void lv_roller_set_selected(lv_obj_t * roller, uint16_t sel_opt, lv_anim_enable_
  */
 void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     lv_roller_ext_t * ext          = lv_obj_get_ext_attr(roller);
     const lv_style_t * style_label = lv_obj_get_style(ext->ddlist.label);
     uint8_t n_line_space           = (row_cnt > 1) ? row_cnt - 1 : 1;
@@ -232,6 +241,8 @@ void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt)
  */
 void lv_roller_set_style(lv_obj_t * roller, lv_roller_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     switch(type) {
         case LV_ROLLER_STYLE_BG: lv_obj_set_style(roller, style); break;
         case LV_ROLLER_STYLE_SEL: lv_ddlist_set_style(roller, LV_DDLIST_STYLE_SEL, style); break;
@@ -249,6 +260,8 @@ void lv_roller_set_style(lv_obj_t * roller, lv_roller_style_t type, const lv_sty
  */
 uint16_t lv_roller_get_selected(const lv_obj_t * roller)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
     if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
         uint16_t real_id_cnt = ext->ddlist.option_cnt / LV_ROLLER_INF_PAGES;
@@ -265,6 +278,8 @@ uint16_t lv_roller_get_selected(const lv_obj_t * roller)
  */
 lv_label_align_t lv_roller_get_align(const lv_obj_t * roller)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
     LV_ASSERT_MEM(ext);
     LV_ASSERT_MEM(ext->ddlist.label);
@@ -278,6 +293,8 @@ lv_label_align_t lv_roller_get_align(const lv_obj_t * roller)
  */
 bool lv_roller_get_hor_fit(const lv_obj_t * roller)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     return lv_page_get_scrl_fit_left(roller);
 }
 
@@ -289,6 +306,8 @@ bool lv_roller_get_hor_fit(const lv_obj_t * roller)
  *  */
 const lv_style_t * lv_roller_get_style(const lv_obj_t * roller, lv_roller_style_t type)
 {
+    LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
+
     switch(type) {
         case LV_ROLLER_STYLE_BG: return lv_obj_get_style(roller);
         case LV_ROLLER_STYLE_SEL: return lv_ddlist_get_style(roller, LV_DDLIST_STYLE_SEL);
@@ -402,7 +421,7 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
         res = ancestor_signal(roller, sign, param);
         if(res != LV_RES_OK) return res;
     }
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(roller, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
 

src/lv_objx/lv_slider.c

@@ -121,6 +121,8 @@ lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_slider_set_knob_in(lv_obj_t * slider, bool in)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
     if(ext->knob_in == in) return;
 
@@ -136,6 +138,8 @@ void lv_slider_set_knob_in(lv_obj_t * slider, bool in)
  */
 void lv_slider_set_style(lv_obj_t * slider, lv_slider_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
 
     switch(type) {
@@ -159,6 +163,8 @@ void lv_slider_set_style(lv_obj_t * slider, lv_slider_style_t type, const lv_sty
  */
 int16_t lv_slider_get_value(const lv_obj_t * slider)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
 
     if(ext->drag_value != LV_SLIDER_NOT_PRESSED)
@@ -174,6 +180,8 @@ int16_t lv_slider_get_value(const lv_obj_t * slider)
  */
 bool lv_slider_is_dragged(const lv_obj_t * slider)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
     return ext->drag_value == LV_SLIDER_NOT_PRESSED ? false : true;
 }
@@ -186,6 +194,8 @@ bool lv_slider_is_dragged(const lv_obj_t * slider)
  */
 bool lv_slider_get_knob_in(const lv_obj_t * slider)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
     return ext->knob_in == 0 ? false : true;
 }
@@ -198,6 +208,8 @@ bool lv_slider_get_knob_in(const lv_obj_t * slider)
  */
 const lv_style_t * lv_slider_get_style(const lv_obj_t * slider, lv_slider_style_t type)
 {
+    LV_ASSERT_OBJ(slider, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_slider_ext_t * ext    = lv_obj_get_ext_attr(slider);
 
@@ -505,7 +517,7 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = ancestor_signal(slider, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(slider, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
     lv_point_t p;

src/lv_objx/lv_spinbox.c

@@ -123,6 +123,8 @@ lv_obj_t * lv_spinbox_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_spinbox_set_value(lv_obj_t * spinbox, int32_t i)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
     if(ext == NULL) return;
 
@@ -143,6 +145,8 @@ void lv_spinbox_set_value(lv_obj_t * spinbox, int32_t i)
  */
 void lv_spinbox_set_digit_format(lv_obj_t * spinbox, uint8_t digit_count, uint8_t separator_position)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
     if(ext == NULL) return;
 
@@ -163,6 +167,8 @@ void lv_spinbox_set_digit_format(lv_obj_t * spinbox, uint8_t digit_count, uint8_
  */
 void lv_spinbox_set_step(lv_obj_t * spinbox, uint32_t step)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
     if(ext == NULL) return;
 
@@ -177,6 +183,8 @@ void lv_spinbox_set_step(lv_obj_t * spinbox, uint32_t step)
  */
 void lv_spinbox_set_range(lv_obj_t * spinbox, int32_t range_min, int32_t range_max)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
     if(ext == NULL) return;
 
@@ -200,6 +208,8 @@ void lv_spinbox_set_range(lv_obj_t * spinbox, int32_t range_min, int32_t range_m
  */
 void lv_spinbox_set_padding_left(lv_obj_t * spinbox, uint8_t padding)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext  = lv_obj_get_ext_attr(spinbox);
     ext->digit_padding_left = padding;
     lv_spinbox_updatevalue(spinbox);
@@ -216,6 +226,8 @@ void lv_spinbox_set_padding_left(lv_obj_t * spinbox, uint8_t padding)
  */
 int32_t lv_spinbox_get_value(lv_obj_t * spinbox)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
 
     return ext->value;
@@ -231,6 +243,8 @@ int32_t lv_spinbox_get_value(lv_obj_t * spinbox)
  */
 void lv_spinbox_step_next(lv_obj_t * spinbox)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
 
     int32_t new_step = ext->step / 10;
@@ -248,6 +262,8 @@ void lv_spinbox_step_next(lv_obj_t * spinbox)
  */
 void lv_spinbox_step_prev(lv_obj_t * spinbox)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
     int32_t step_limit;
     step_limit       = LV_MATH_MAX(ext->range_max, (ext->range_min < 0 ? (-ext->range_min) : ext->range_min));
@@ -263,6 +279,8 @@ void lv_spinbox_step_prev(lv_obj_t * spinbox)
  */
 void lv_spinbox_increment(lv_obj_t * spinbox)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
 
     if(ext->value + ext->step <= ext->range_max) {
@@ -283,6 +301,8 @@ void lv_spinbox_increment(lv_obj_t * spinbox)
  */
 void lv_spinbox_decrement(lv_obj_t * spinbox)
 {
+    LV_ASSERT_OBJ(spinbox, LV_OBJX_NAME);
+
     lv_spinbox_ext_t * ext = lv_obj_get_ext_attr(spinbox);
 
     if(ext->value - ext->step >= ext->range_min) {
@@ -319,7 +339,7 @@ static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * p
         res = ancestor_signal(spinbox, sign, param);
         if(res != LV_RES_OK) return res;
     }
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(spinbox, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_sw.c

@@ -131,6 +131,8 @@ lv_obj_t * lv_sw_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_sw_on(lv_obj_t * sw, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -146,6 +148,8 @@ void lv_sw_on(lv_obj_t * sw, lv_anim_enable_t anim)
  */
 void lv_sw_off(lv_obj_t * sw, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -162,6 +166,8 @@ void lv_sw_off(lv_obj_t * sw, lv_anim_enable_t anim)
  */
 bool lv_sw_toggle(lv_obj_t * sw, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -183,6 +189,8 @@ bool lv_sw_toggle(lv_obj_t * sw, lv_anim_enable_t anim)
  */
 void lv_sw_set_style(lv_obj_t * sw, lv_sw_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
     lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw);
 
     switch(type) {
@@ -201,6 +209,8 @@ void lv_sw_set_style(lv_obj_t * sw, lv_sw_style_t type, const lv_style_t * style
 
 void lv_sw_set_anim_time(lv_obj_t * sw, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw);
     ext->anim_time    = anim_time;
@@ -222,6 +232,8 @@ void lv_sw_set_anim_time(lv_obj_t * sw, uint16_t anim_time)
  */
 const lv_style_t * lv_sw_get_style(const lv_obj_t * sw, lv_sw_style_t type)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_sw_ext_t * ext        = lv_obj_get_ext_attr(sw);
 
@@ -238,6 +250,7 @@ const lv_style_t * lv_sw_get_style(const lv_obj_t * sw, lv_sw_style_t type)
 
 uint16_t lv_sw_get_anim_time(const lv_obj_t * sw)
 {
+    LV_ASSERT_OBJ(sw, LV_OBJX_NAME);
 
 #if LV_USE_ANIMATION
     lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw);
@@ -280,7 +293,7 @@ static lv_res_t lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
 
     res = ancestor_signal(sw, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(sw, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     sw->event_cb = event_cb;
 

src/lv_objx/lv_ta.c

@@ -226,6 +226,8 @@ lv_obj_t * lv_ta_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_ta_add_char(lv_obj_t * ta, uint32_t c)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     uint32_t letter_buf[2];
@@ -314,6 +316,9 @@ void lv_ta_add_char(lv_obj_t * ta, uint32_t c)
  */
 void lv_ta_add_text(lv_obj_t * ta, const char * txt)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+    LV_ASSERT_NULL(txt);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     ta_insert_replace = NULL;
@@ -393,6 +398,8 @@ void lv_ta_add_text(lv_obj_t * ta, const char * txt)
  */
 void lv_ta_del_char(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     uint16_t cur_pos  = ext->cursor.pos;
 
@@ -447,6 +454,8 @@ void lv_ta_del_char(lv_obj_t * ta)
  */
 void lv_ta_del_char_forward(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     uint16_t cp = lv_ta_get_cursor_pos(ta);
     lv_ta_set_cursor_pos(ta, cp + 1);
     if(cp != lv_ta_get_cursor_pos(ta)) lv_ta_del_char(ta);
@@ -463,6 +472,9 @@ void lv_ta_del_char_forward(lv_obj_t * ta)
  */
 void lv_ta_set_text(lv_obj_t * ta, const char * txt)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+    LV_ASSERT_NULL(txt);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     /*Clear the existing selection*/
@@ -528,6 +540,9 @@ void lv_ta_set_text(lv_obj_t * ta, const char * txt)
  */
 void lv_ta_set_placeholder_text(lv_obj_t * ta, const char * txt)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+    LV_ASSERT_NULL(txt);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     /*Create the placeholder label only when it is needed*/
@@ -555,6 +570,8 @@ void lv_ta_set_placeholder_text(lv_obj_t * ta, const char * txt)
  */
 void lv_ta_set_cursor_pos(lv_obj_t * ta, int16_t pos)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     if(ext->cursor.pos == pos) return;
 
@@ -631,6 +648,8 @@ void lv_ta_set_cursor_pos(lv_obj_t * ta, int16_t pos)
  */
 void lv_ta_set_cursor_type(lv_obj_t * ta, lv_cursor_type_t cur_type)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     if(ext->cursor.type == cur_type) return;
 
@@ -646,6 +665,8 @@ void lv_ta_set_cursor_type(lv_obj_t * ta, lv_cursor_type_t cur_type)
  */
 void lv_ta_set_cursor_click_pos(lv_obj_t * ta, bool en)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext     = lv_obj_get_ext_attr(ta);
     ext->cursor.click_pos = en ? 1 : 0;
 }
@@ -657,6 +678,8 @@ void lv_ta_set_cursor_click_pos(lv_obj_t * ta, bool en)
  */
 void lv_ta_set_pwd_mode(lv_obj_t * ta, bool en)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     if(ext->pwd_mode == en) return;
 
@@ -701,6 +724,8 @@ void lv_ta_set_pwd_mode(lv_obj_t * ta, bool en)
  */
 void lv_ta_set_one_line(lv_obj_t * ta, bool en)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     if(ext->one_line == en) return;
 
@@ -742,6 +767,8 @@ void lv_ta_set_one_line(lv_obj_t * ta, bool en)
  */
 void lv_ta_set_text_align(lv_obj_t * ta, lv_label_align_t align)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     lv_obj_t * label  = lv_ta_get_label(ta);
     if(!ext->one_line) {
@@ -774,6 +801,8 @@ void lv_ta_set_text_align(lv_obj_t * ta, lv_label_align_t align)
  */
 void lv_ta_set_accepted_chars(lv_obj_t * ta, const char * list)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     ext->accapted_chars = list;
@@ -786,6 +815,8 @@ void lv_ta_set_accepted_chars(lv_obj_t * ta, const char * list)
  */
 void lv_ta_set_max_length(lv_obj_t * ta, uint16_t num)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     ext->max_length = num;
@@ -801,6 +832,8 @@ void lv_ta_set_max_length(lv_obj_t * ta, uint16_t num)
  */
 void lv_ta_set_insert_replace(lv_obj_t * ta, const char * txt)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     (void)ta; /*Unused*/
     ta_insert_replace = txt;
 }
@@ -813,6 +846,8 @@ void lv_ta_set_insert_replace(lv_obj_t * ta, const char * txt)
  */
 void lv_ta_set_style(lv_obj_t * ta, lv_ta_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     switch(type) {
@@ -837,6 +872,8 @@ void lv_ta_set_style(lv_obj_t * ta, lv_ta_style_t type, const lv_style_t * style
  */
 void lv_ta_set_text_sel(lv_obj_t * ta, bool en)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_LABEL_TEXT_SEL
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
@@ -856,6 +893,8 @@ void lv_ta_set_text_sel(lv_obj_t * ta, bool en)
  */
 void lv_ta_set_pwd_show_time(lv_obj_t * ta, uint16_t time)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     time = 0;
 #endif
@@ -871,6 +910,8 @@ void lv_ta_set_pwd_show_time(lv_obj_t * ta, uint16_t time)
  */
 void lv_ta_set_cursor_blink_time(lv_obj_t * ta, uint16_t time)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     time = 0;
 #endif
@@ -914,6 +955,8 @@ void lv_ta_set_cursor_blink_time(lv_obj_t * ta, uint16_t time)
  */
 const char * lv_ta_get_text(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     const char * txt;
@@ -933,6 +976,8 @@ const char * lv_ta_get_text(const lv_obj_t * ta)
  */
 const char * lv_ta_get_placeholder_text(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     const char * txt = NULL;
@@ -949,6 +994,8 @@ const char * lv_ta_get_placeholder_text(lv_obj_t * ta)
  */
 lv_obj_t * lv_ta_get_label(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->label;
 }
@@ -960,6 +1007,8 @@ lv_obj_t * lv_ta_get_label(const lv_obj_t * ta)
  */
 uint16_t lv_ta_get_cursor_pos(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->cursor.pos;
 }
@@ -971,6 +1020,8 @@ uint16_t lv_ta_get_cursor_pos(const lv_obj_t * ta)
  */
 lv_cursor_type_t lv_ta_get_cursor_type(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->cursor.type;
 }
@@ -982,6 +1033,8 @@ lv_cursor_type_t lv_ta_get_cursor_type(const lv_obj_t * ta)
  */
 bool lv_ta_get_cursor_click_pos(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->cursor.click_pos ? true : false;
 }
@@ -993,6 +1046,8 @@ bool lv_ta_get_cursor_click_pos(lv_obj_t * ta)
  */
 bool lv_ta_get_pwd_mode(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->pwd_mode == 0 ? false : true;
 }
@@ -1004,6 +1059,8 @@ bool lv_ta_get_pwd_mode(const lv_obj_t * ta)
  */
 bool lv_ta_get_one_line(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->one_line == 0 ? false : true;
 }
@@ -1015,6 +1072,8 @@ bool lv_ta_get_one_line(const lv_obj_t * ta)
  */
 const char * lv_ta_get_accepted_chars(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     return ext->accapted_chars;
@@ -1027,6 +1086,8 @@ const char * lv_ta_get_accepted_chars(lv_obj_t * ta)
  */
 uint16_t lv_ta_get_max_length(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->max_length;
 }
@@ -1039,6 +1100,8 @@ uint16_t lv_ta_get_max_length(lv_obj_t * ta)
  */
 const lv_style_t * lv_ta_get_style(const lv_obj_t * ta, lv_ta_style_t type)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_ta_ext_t * ext        = lv_obj_get_ext_attr(ta);
 
@@ -1063,6 +1126,8 @@ const lv_style_t * lv_ta_get_style(const lv_obj_t * ta, lv_ta_style_t type)
  */
 bool lv_ta_text_is_selected(const lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_LABEL_TEXT_SEL
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
@@ -1085,6 +1150,8 @@ bool lv_ta_text_is_selected(const lv_obj_t * ta)
  */
 bool lv_ta_get_text_sel_en(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_LABEL_TEXT_SEL
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->text_sel_en;
@@ -1101,6 +1168,8 @@ bool lv_ta_get_text_sel_en(lv_obj_t * ta)
  */
 uint16_t lv_ta_get_pwd_show_time(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
     return ext->pwd_show_time;
@@ -1113,6 +1182,8 @@ uint16_t lv_ta_get_pwd_show_time(lv_obj_t * ta)
  */
 uint16_t lv_ta_get_cursor_blink_time(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     return ext->cursor.blink_time;
 }
@@ -1127,6 +1198,8 @@ uint16_t lv_ta_get_cursor_blink_time(lv_obj_t * ta)
  */
 void lv_ta_clear_selection(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
 #if LV_LABEL_TEXT_SEL
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
 
@@ -1146,6 +1219,8 @@ void lv_ta_clear_selection(lv_obj_t * ta)
  */
 void lv_ta_cursor_right(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     uint16_t cp = lv_ta_get_cursor_pos(ta);
     cp++;
     lv_ta_set_cursor_pos(ta, cp);
@@ -1157,6 +1232,8 @@ void lv_ta_cursor_right(lv_obj_t * ta)
  */
 void lv_ta_cursor_left(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     uint16_t cp = lv_ta_get_cursor_pos(ta);
     if(cp > 0) {
         cp--;
@@ -1170,6 +1247,8 @@ void lv_ta_cursor_left(lv_obj_t * ta)
  */
 void lv_ta_cursor_down(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     lv_point_t pos;
 
@@ -1200,6 +1279,8 @@ void lv_ta_cursor_down(lv_obj_t * ta)
  */
 void lv_ta_cursor_up(lv_obj_t * ta)
 {
+    LV_ASSERT_OBJ(ta, LV_OBJX_NAME);
+
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     lv_point_t pos;
 
@@ -1333,7 +1414,7 @@ static lv_res_t lv_ta_signal(lv_obj_t * ta, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(ta, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(ta, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
     if(sign == LV_SIGNAL_CLEANUP) {
@@ -1457,7 +1538,7 @@ static lv_res_t lv_ta_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void
     /* Include the ancient signal function */
     res = scrl_signal(scrl, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(scrl, param, "");
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
     lv_obj_t * ta     = lv_obj_get_parent(scrl);
     lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);

src/lv_objx/lv_table.c

@@ -134,6 +134,9 @@ lv_obj_t * lv_table_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_table_set_cell_value(lv_obj_t * table, uint16_t row, uint16_t col, const char * txt)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+    LV_ASSERT_NULL(txt);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_value: invalid row or column");
@@ -167,6 +170,8 @@ void lv_table_set_cell_value(lv_obj_t * table, uint16_t row, uint16_t col, const
  */
 void lv_table_set_row_cnt(lv_obj_t * table, uint16_t row_cnt)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     uint16_t old_row_cnt = ext->row_cnt;
     ext->row_cnt         = row_cnt;
@@ -195,6 +200,7 @@ void lv_table_set_row_cnt(lv_obj_t * table, uint16_t row_cnt)
  */
 void lv_table_set_col_cnt(lv_obj_t * table, uint16_t col_cnt)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
 
     if(col_cnt >= LV_TABLE_COL_MAX) {
         LV_LOG_WARN("lv_table_set_col_cnt: too many columns. Must be < LV_TABLE_COL_MAX.");
@@ -229,6 +235,8 @@ void lv_table_set_col_cnt(lv_obj_t * table, uint16_t col_cnt)
  */
 void lv_table_set_col_width(lv_obj_t * table, uint16_t col_id, lv_coord_t w)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     if(col_id >= LV_TABLE_COL_MAX) {
         LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
         return;
@@ -248,6 +256,8 @@ void lv_table_set_col_width(lv_obj_t * table, uint16_t col_id, lv_coord_t w)
  */
 void lv_table_set_cell_align(lv_obj_t * table, uint16_t row, uint16_t col, lv_label_align_t align)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_align: invalid row or column");
@@ -276,6 +286,8 @@ void lv_table_set_cell_align(lv_obj_t * table, uint16_t row, uint16_t col, lv_la
  */
 void lv_table_set_cell_type(lv_obj_t * table, uint16_t row, uint16_t col, uint8_t type)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_type: invalid row or column");
@@ -307,6 +319,8 @@ void lv_table_set_cell_type(lv_obj_t * table, uint16_t row, uint16_t col, uint8_
  */
 void lv_table_set_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col, bool crop)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_crop: invalid row or column");
@@ -335,6 +349,8 @@ void lv_table_set_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col, bool c
  */
 void lv_table_set_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col, bool en)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_merge_right: invalid row or column");
@@ -364,6 +380,8 @@ void lv_table_set_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col,
  */
 void lv_table_set_style(lv_obj_t * table, lv_table_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
 
     switch(type) {
@@ -403,6 +421,8 @@ void lv_table_set_style(lv_obj_t * table, lv_table_style_t type, const lv_style_
  */
 const char * lv_table_get_cell_value(lv_obj_t * table, uint16_t row, uint16_t col)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_value: invalid row or column");
@@ -422,6 +442,8 @@ const char * lv_table_get_cell_value(lv_obj_t * table, uint16_t row, uint16_t co
  */
 uint16_t lv_table_get_row_cnt(lv_obj_t * table)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     return ext->row_cnt;
 }
@@ -433,6 +455,8 @@ uint16_t lv_table_get_row_cnt(lv_obj_t * table)
  */
 uint16_t lv_table_get_col_cnt(lv_obj_t * table)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     return ext->col_cnt;
 }
@@ -445,6 +469,8 @@ uint16_t lv_table_get_col_cnt(lv_obj_t * table)
  */
 lv_coord_t lv_table_get_col_width(lv_obj_t * table, uint16_t col_id)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     if(col_id >= LV_TABLE_COL_MAX) {
         LV_LOG_WARN("lv_table_set_col_width: too big 'col_id'. Must be < LV_TABLE_COL_MAX.");
         return 0;
@@ -464,6 +490,8 @@ lv_coord_t lv_table_get_col_width(lv_obj_t * table, uint16_t col_id)
  */
 lv_label_align_t lv_table_get_cell_align(lv_obj_t * table, uint16_t row, uint16_t col)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_set_cell_align: invalid row or column");
@@ -489,6 +517,8 @@ lv_label_align_t lv_table_get_cell_align(lv_obj_t * table, uint16_t row, uint16_
  */
 lv_label_align_t lv_table_get_cell_type(lv_obj_t * table, uint16_t row, uint16_t col)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_get_cell_type: invalid row or column");
@@ -514,6 +544,8 @@ lv_label_align_t lv_table_get_cell_type(lv_obj_t * table, uint16_t row, uint16_t
  */
 lv_label_align_t lv_table_get_cell_crop(lv_obj_t * table, uint16_t row, uint16_t col)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_get_cell_crop: invalid row or column");
@@ -539,6 +571,8 @@ lv_label_align_t lv_table_get_cell_crop(lv_obj_t * table, uint16_t row, uint16_t
  */
 bool lv_table_get_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext = lv_obj_get_ext_attr(table);
     if(row >= ext->row_cnt || col >= ext->col_cnt) {
         LV_LOG_WARN("lv_table_get_cell_merge_right: invalid row or column");
@@ -564,6 +598,8 @@ bool lv_table_get_cell_merge_right(lv_obj_t * table, uint16_t row, uint16_t col)
  */
 const lv_style_t * lv_table_get_style(const lv_obj_t * table, lv_table_style_t type)
 {
+    LV_ASSERT_OBJ(table, LV_OBJX_NAME);
+
     lv_table_ext_t * ext     = lv_obj_get_ext_attr(table);
     const lv_style_t * style = NULL;
 
@@ -743,7 +779,7 @@ static lv_res_t lv_table_signal(lv_obj_t * table, lv_signal_t sign, void * param
     /* Include the ancient signal function */
     res = ancestor_signal(table, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(table, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Free the cell texts*/

src/lv_objx/lv_tabview.c

@@ -191,11 +191,13 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param tabview pointer to an object
  */
-void lv_tabview_clean(lv_obj_t * obj)
+void lv_tabview_clean(lv_obj_t * tabview)
 {
-    lv_obj_t * scrl = lv_page_get_scrl(obj);
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
+    lv_obj_t * scrl = lv_page_get_scrl(tabview);
     lv_obj_clean(scrl);
 }
 
@@ -211,6 +213,9 @@ void lv_tabview_clean(lv_obj_t * obj)
  */
 lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+    LV_ASSERT_STR(name);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
 
     /*Create the container page*/
@@ -331,6 +336,8 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
  */
 void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -455,6 +462,8 @@ void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t an
  */
 void lv_tabview_set_sliding(lv_obj_t * tabview, bool en)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     ext->slide_enable      = en == false ? 0 : 1;
 }
@@ -466,6 +475,8 @@ void lv_tabview_set_sliding(lv_obj_t * tabview, bool en)
  */
 void lv_tabview_set_anim_time(lv_obj_t * tabview, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     ext->anim_time         = anim_time;
@@ -483,6 +494,8 @@ void lv_tabview_set_anim_time(lv_obj_t * tabview, uint16_t anim_time)
  */
 void lv_tabview_set_style(lv_obj_t * tabview, lv_tabview_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
 
     switch(type) {
@@ -520,6 +533,8 @@ void lv_tabview_set_style(lv_obj_t * tabview, lv_tabview_style_t type, const lv_
  */
 void lv_tabview_set_btns_pos(lv_obj_t * tabview, lv_tabview_btns_pos_t btns_pos)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
 
     ext->btns_pos = btns_pos;
@@ -533,6 +548,8 @@ void lv_tabview_set_btns_pos(lv_obj_t * tabview, lv_tabview_btns_pos_t btns_pos)
  */
 void lv_tabview_set_btns_hidden(lv_obj_t * tabview, bool en)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
 
     ext->btns_hide = en;
@@ -550,6 +567,8 @@ void lv_tabview_set_btns_hidden(lv_obj_t * tabview, bool en)
  */
 uint16_t lv_tabview_get_tab_act(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     return ext->tab_cur;
 }
@@ -561,6 +580,8 @@ uint16_t lv_tabview_get_tab_act(const lv_obj_t * tabview)
  */
 uint16_t lv_tabview_get_tab_count(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     return ext->tab_cnt;
 }
@@ -573,6 +594,8 @@ uint16_t lv_tabview_get_tab_count(const lv_obj_t * tabview)
  */
 lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     uint16_t i             = 0;
     lv_obj_t * page        = lv_obj_get_child_back(ext->content, NULL);
@@ -594,6 +617,8 @@ lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id)
  */
 bool lv_tabview_get_sliding(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     return ext->slide_enable ? true : false;
 }
@@ -605,6 +630,8 @@ bool lv_tabview_get_sliding(const lv_obj_t * tabview)
  */
 uint16_t lv_tabview_get_anim_time(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     return ext->anim_time;
@@ -622,6 +649,8 @@ uint16_t lv_tabview_get_anim_time(const lv_obj_t * tabview)
  */
 const lv_style_t * lv_tabview_get_style(const lv_obj_t * tabview, lv_tabview_style_t type)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_tabview_ext_t * ext   = lv_obj_get_ext_attr(tabview);
 
@@ -644,6 +673,8 @@ const lv_style_t * lv_tabview_get_style(const lv_obj_t * tabview, lv_tabview_sty
  */
 lv_tabview_btns_pos_t lv_tabview_get_btns_pos(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     return ext->btns_pos;
 }
@@ -655,6 +686,8 @@ lv_tabview_btns_pos_t lv_tabview_get_btns_pos(const lv_obj_t * tabview)
  */
 bool lv_tabview_get_btns_hidden(const lv_obj_t * tabview)
 {
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
 
     return ext->btns_hide;
@@ -678,7 +711,7 @@ static lv_res_t lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * p
     /* Include the ancient signal function */
     res = ancestor_signal(tabview, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(tabview, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
     if(sign == LV_SIGNAL_CLEANUP) {
@@ -752,7 +785,7 @@ static lv_res_t tabpage_signal(lv_obj_t * tab_page, lv_signal_t sign, void * par
     /* Include the ancient signal function */
     res = page_signal(tab_page, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(tab_page, param, "");
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
     lv_obj_t * cont    = lv_obj_get_parent(tab_page);
     lv_obj_t * tabview = lv_obj_get_parent(cont);
@@ -783,7 +816,7 @@ static lv_res_t tabpage_scrl_signal(lv_obj_t * tab_scrl, lv_signal_t sign, void
     /* Include the ancient signal function */
     res = page_scrl_signal(tab_scrl, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(tab_scrl, param, "");
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
 
     lv_obj_t * tab_page = lv_obj_get_parent(tab_scrl);
     lv_obj_t * cont     = lv_obj_get_parent(tab_page);

src/lv_objx/lv_tabview.h

@@ -94,9 +94,9 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy);
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param tabview pointer to an object
  */
-void lv_tabview_clean(lv_obj_t * obj);
+void lv_tabview_clean(lv_obj_t * tabview);
 
 /*======================
  * Add/remove functions

src/lv_objx/lv_tileview.c

@@ -145,6 +145,9 @@ lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy)
  */
 void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element)
 {
+    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
+    LV_ASSERT_NULL(tileview);
+
     /* Let the objects event to propagate to the scrollable part of the tileview.
      * It is required the handle dargging of the tileview with the element.*/
     element->parent_event = 1;
@@ -170,6 +173,9 @@ void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element)
  */
 void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t * valid_pos, uint16_t valid_pos_cnt)
 {
+    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
+    LV_ASSERT_NULL(valid_pos);
+
     lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
     ext->valid_pos          = valid_pos;
     ext->valid_pos_cnt      = valid_pos_cnt;
@@ -197,6 +203,8 @@ void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t * val
  */
 void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, lv_anim_enable_t anim)
 {
+    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
+
 #if LV_USE_ANIMATION == 0
     anim = LV_ANIM_OFF;
 #endif
@@ -266,6 +274,7 @@ void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, l
  */
 void lv_tileview_set_style(lv_obj_t * tileview, lv_tileview_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
 
     switch(type) {
         case LV_TILEVIEW_STYLE_MAIN: lv_obj_set_style(tileview, style); break;
@@ -288,6 +297,8 @@ void lv_tileview_set_style(lv_obj_t * tileview, lv_tileview_style_t type, const
  */
 const lv_style_t * lv_tileview_get_style(const lv_obj_t * tileview, lv_tileview_style_t type)
 {
+    LV_ASSERT_OBJ(tileview, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     switch(type) {
         case LV_TILEVIEW_STYLE_MAIN: style = lv_obj_get_style(tileview); break;
@@ -323,7 +334,7 @@ static lv_res_t lv_tileview_signal(lv_obj_t * tileview, lv_signal_t sign, void *
     /* Include the ancient signal function */
     res = ancestor_signal(tileview, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(tileview, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     if(sign == LV_SIGNAL_CLEANUP) {
         /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/

src/lv_objx/lv_win.c

@@ -148,11 +148,13 @@ lv_obj_t * lv_win_create(lv_obj_t * par, const lv_obj_t * copy)
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param win pointer to an object
  */
-void lv_win_clean(lv_obj_t * obj)
+void lv_win_clean(lv_obj_t * win)
 {
-    lv_obj_t * scrl = lv_page_get_scrl(obj);
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
+    lv_obj_t * scrl = lv_page_get_scrl(win);
     lv_obj_clean(scrl);
 }
 
@@ -168,6 +170,9 @@ void lv_win_clean(lv_obj_t * obj)
  */
 lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * img_src)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+    LV_ASSERT_NULL(img_src);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
 
     lv_obj_t * btn = lv_btn_create(ext->header, NULL);
@@ -195,6 +200,8 @@ lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * img_src)
  */
 void lv_win_close_event_cb(lv_obj_t * btn, lv_event_t event)
 {
+    LV_ASSERT_OBJ(btn, "lv_btn");
+
     if(event == LV_EVENT_RELEASED) {
         lv_obj_t * win = lv_win_get_from_btn(btn);
 
@@ -209,6 +216,9 @@ void lv_win_close_event_cb(lv_obj_t * btn, lv_event_t event)
  */
 void lv_win_set_title(lv_obj_t * win, const char * title)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+    LV_ASSERT_STR(title);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
 
     lv_label_set_text(ext->title, title);
@@ -222,6 +232,8 @@ void lv_win_set_title(lv_obj_t * win, const char * title)
  */
 void lv_win_set_btn_size(lv_obj_t * win, lv_coord_t size)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     if(ext->btn_size == size) return;
 
@@ -238,6 +250,8 @@ void lv_win_set_btn_size(lv_obj_t * win, lv_coord_t size)
  */
 void lv_win_set_content_size(lv_obj_t * win, lv_coord_t w, lv_coord_t h)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     h += lv_obj_get_height(ext->header);
 }
@@ -249,6 +263,8 @@ void lv_win_set_content_size(lv_obj_t * win, lv_coord_t w, lv_coord_t h)
  */
 void lv_win_set_layout(lv_obj_t * win, lv_layout_t layout)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     lv_page_set_scrl_layout(ext->page, layout);
 }
@@ -260,6 +276,8 @@ void lv_win_set_layout(lv_obj_t * win, lv_layout_t layout)
  */
 void lv_win_set_sb_mode(lv_obj_t * win, lv_sb_mode_t sb_mode)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     lv_page_set_sb_mode(ext->page, sb_mode);
 }
@@ -270,6 +288,8 @@ void lv_win_set_sb_mode(lv_obj_t * win, lv_sb_mode_t sb_mode)
  */
 void lv_win_set_anim_time(lv_obj_t * win, uint16_t anim_time)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_page_set_anim_time(lv_win_get_content(win), anim_time);
 }
 
@@ -281,6 +301,8 @@ void lv_win_set_anim_time(lv_obj_t * win, uint16_t anim_time)
  */
 void lv_win_set_style(lv_obj_t * win, lv_win_style_t type, const lv_style_t * style)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
 
     switch(type) {
@@ -320,6 +342,8 @@ void lv_win_set_style(lv_obj_t * win, lv_win_style_t type, const lv_style_t * st
  */
 void lv_win_set_drag(lv_obj_t * win, bool en)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext    = lv_obj_get_ext_attr(win);
     lv_obj_t * win_header = ext->header;
     lv_obj_set_drag_parent(win_header, en);
@@ -337,6 +361,8 @@ void lv_win_set_drag(lv_obj_t * win, bool en)
  */
 const char * lv_win_get_title(const lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     return lv_label_get_text(ext->title);
 }
@@ -348,6 +374,8 @@ const char * lv_win_get_title(const lv_obj_t * win)
  */
 lv_obj_t * lv_win_get_content(const lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     return ext->page;
 }
@@ -359,6 +387,8 @@ lv_obj_t * lv_win_get_content(const lv_obj_t * win)
  */
 lv_coord_t lv_win_get_btn_size(const lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     return ext->btn_size;
 }
@@ -371,6 +401,8 @@ lv_coord_t lv_win_get_btn_size(const lv_obj_t * win)
  */
 lv_obj_t * lv_win_get_from_btn(const lv_obj_t * ctrl_btn)
 {
+    LV_ASSERT_OBJ(ctrl_btn, "lv_btn");
+
     lv_obj_t * header = lv_obj_get_parent(ctrl_btn);
     lv_obj_t * win    = lv_obj_get_parent(header);
 
@@ -384,6 +416,8 @@ lv_obj_t * lv_win_get_from_btn(const lv_obj_t * ctrl_btn)
  */
 lv_layout_t lv_win_get_layout(lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     return lv_page_get_scrl_layout(ext->page);
 }
@@ -395,6 +429,8 @@ lv_layout_t lv_win_get_layout(lv_obj_t * win)
  */
 lv_sb_mode_t lv_win_get_sb_mode(lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     return lv_page_get_sb_mode(ext->page);
 }
@@ -406,6 +442,8 @@ lv_sb_mode_t lv_win_get_sb_mode(lv_obj_t * win)
  */
 uint16_t lv_win_get_anim_time(const lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     return lv_page_get_anim_time(lv_win_get_content(win));
 }
 
@@ -416,6 +454,8 @@ uint16_t lv_win_get_anim_time(const lv_obj_t * win)
  */
 lv_coord_t lv_win_get_width(lv_obj_t * win)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     lv_win_ext_t * ext            = lv_obj_get_ext_attr(win);
     lv_obj_t * scrl               = lv_page_get_scrl(ext->page);
     const lv_style_t * style_scrl = lv_obj_get_style(scrl);
@@ -431,6 +471,8 @@ lv_coord_t lv_win_get_width(lv_obj_t * win)
  */
 const lv_style_t * lv_win_get_style(const lv_obj_t * win, lv_win_style_t type)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+
     const lv_style_t * style = NULL;
     lv_win_ext_t * ext       = lv_obj_get_ext_attr(win);
 
@@ -459,6 +501,10 @@ const lv_style_t * lv_win_get_style(const lv_obj_t * win, lv_win_style_t type)
  */
 void lv_win_focus(lv_obj_t * win, lv_obj_t * obj, lv_anim_enable_t anim_en)
 {
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+    LV_ASSERT_OBJ(obj, "");
+
+
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     lv_page_focus(ext->page, obj, anim_en);
 }
@@ -481,7 +527,7 @@ static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param)
     /* Include the ancient signal function */
     res = ancestor_signal(win, sign, param);
     if(res != LV_RES_OK) return res;
-    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(win, param, LV_OBJX_NAME);
+    if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
     if(sign == LV_SIGNAL_CHILD_CHG) { /*Move children to the page*/

src/lv_objx/lv_win.h

@@ -91,9 +91,9 @@ lv_obj_t * lv_win_create(lv_obj_t * par, const lv_obj_t * copy);
 
 /**
  * Delete all children of the scrl object, without deleting scrl child.
- * @param obj pointer to an object
+ * @param win pointer to an object
  */
-void lv_win_clean(lv_obj_t * obj);
+void lv_win_clean(lv_obj_t * win);
 
 /*======================
  * Add/remove functions