Mirrors_UI_SDK/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2026-09-21 10:35:23 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

feat: introduces LV_CHECK_ARG (#9986)

Browse Source 
Co-authored-by: André Costa <andre_miguel_costa@hotmail.com>
This commit is contained in:
Akos Vandra-Meyer
2026-05-05 18:48:17 +08:00
committed by GitHub
co-authored by André Costa
parent 1e12358523
commit 78f2b5139d
28 changed files with 768 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/lv_group.c
+46 -37
View File
@@ -9,6 +9,7 @@
#include "lv_group_private.h"
#include "../core/lv_obj_private.h"
#include "../core/lv_global.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -75,8 +76,9 @@ lv_group_t * lv_group_create(void)
void lv_group_delete(lv_group_t * group)
{
if(group == NULL) return;
/*Defocus the currently focused object*/
LV_ASSERT_NULL(group);
if(group->obj_focus != NULL) {
lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
lv_obj_invalidate(*group->obj_focus);
@@ -123,7 +125,8 @@ lv_group_t * lv_group_get_default(void)
void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
{
if(group == NULL) return;
LV_CHECK_ARG(group != NULL, return);
LV_CHECK_ARG(obj != NULL, return);
LV_LOG_TRACE("begin");
@@ -131,6 +134,8 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
return;
}
LV_ASSERT_NULL(obj->spec_attr);
/*Be sure the object is removed from its current group*/
lv_group_remove_obj(obj);
obj->spec_attr->group_p = group;
@@ -151,8 +156,12 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
void lv_group_swap_obj(lv_obj_t * obj1, lv_obj_t * obj2)
{
LV_CHECK_ARG(obj1 != NULL, return);
LV_CHECK_ARG(obj2 != NULL, return);
lv_group_t * g1 = lv_obj_get_group(obj1);
lv_group_t * g2 = lv_obj_get_group(obj2);
if(g1 != g2) return;
if(g1 == NULL) return;
@@ -163,10 +172,10 @@ void lv_group_swap_obj(lv_obj_t * obj1, lv_obj_t * obj2)
else if((*obj_i) == obj2)(*obj_i) = obj1;
}
// Swap the focus as well.
lv_obj_t * focused = lv_group_get_focused(g1);
if(focused == obj1) lv_group_focus_obj(obj2);
else if(focused == obj2) lv_group_focus_obj(obj1);
}
void lv_group_remove_obj(lv_obj_t * obj)
@@ -176,7 +185,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
LV_LOG_TRACE("begin");
/*Focus on the next object*/
/* If we are removing the focused object */
if(g->obj_focus && *g->obj_focus == obj) {
if(g->frozen) g->frozen = 0;
@@ -212,7 +221,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
void lv_group_remove_all_objs(lv_group_t * group)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
/*Defocus the currently focused object*/
if(group->obj_focus != NULL) {
@@ -232,11 +241,12 @@ void lv_group_remove_all_objs(lv_group_t * group)
void lv_group_focus_obj(lv_obj_t * obj)
{
if(obj == NULL) return;
lv_group_t * g = lv_obj_get_group(obj);
if(g == NULL) return;
LV_CHECK_ARG(obj != NULL, return);
if(g->frozen != 0) return;
lv_group_t * g = lv_obj_get_group(obj);
if(g == NULL) return;
if(g->frozen) return;
/*On defocus edit mode must be leaved*/
lv_group_set_editing(g, false);
@@ -265,29 +275,29 @@ void lv_group_focus_obj(lv_obj_t * obj)
void lv_group_focus_next(lv_group_t * group)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
bool focus_changed = focus_next_core(group, lv_ll_get_head, lv_ll_get_next);
if(group->edge_cb) {
if(!focus_changed)
group->edge_cb(group, true);
if(!focus_changed && group->edge_cb) {
group->edge_cb(group, true);
}
}
void lv_group_focus_prev(lv_group_t * group)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
bool focus_changed = focus_next_core(group, lv_ll_get_tail, lv_ll_get_prev);
if(group->edge_cb) {
if(!focus_changed)
group->edge_cb(group, false);
if(!focus_changed && group->edge_cb) {
group->edge_cb(group, false);
}
}
void lv_group_focus_freeze(lv_group_t * group, bool en)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
if(en == false) group->frozen = 0;
else group->frozen = 1;
@@ -295,7 +305,7 @@ void lv_group_focus_freeze(lv_group_t * group, bool en)
lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return LV_RESULT_INVALID);
lv_obj_t * act = lv_group_get_focused(group);
if(act == NULL) return LV_RESULT_OK;
@@ -307,21 +317,21 @@ lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c)
void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb)
{
if(group == NULL) return;
LV_CHECK_ARG(group != NULL, return);
group->focus_cb = focus_cb;
}
void lv_group_set_edge_cb(lv_group_t * group, lv_group_edge_cb_t edge_cb)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
group->edge_cb = edge_cb;
}
void lv_group_set_editing(lv_group_t * group, bool edit)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
uint8_t en_val = edit ? 1 : 0;
if(en_val == group->editing) return; /*Do not set the same mode again*/
@@ -339,19 +349,19 @@ void lv_group_set_editing(lv_group_t * group, bool edit)
void lv_group_set_refocus_policy(lv_group_t * group, lv_group_refocus_policy_t policy)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
group->refocus_policy = policy & 0x01;
}
void lv_group_set_wrap(lv_group_t * group, bool en)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return);
group->wrap = en ? 1 : 0;
}
lv_obj_t * lv_group_get_focused(const lv_group_t * group)
{
if(!group) return NULL;
LV_CHECK_ARG(group != NULL, return NULL);
if(group->obj_focus == NULL) return NULL;
return *group->obj_focus;
@@ -359,36 +369,37 @@ lv_obj_t * lv_group_get_focused(const lv_group_t * group)
lv_group_focus_cb_t lv_group_get_focus_cb(const lv_group_t * group)
{
if(!group) return NULL;
LV_CHECK_ARG(group != NULL, return NULL);
return group->focus_cb;
}
lv_group_edge_cb_t lv_group_get_edge_cb(const lv_group_t * group)
{
if(!group) return NULL;
LV_CHECK_ARG(group != NULL, return NULL);
return group->edge_cb;
}
bool lv_group_get_editing(const lv_group_t * group)
{
if(!group) return false;
LV_CHECK_ARG(group != NULL, return false);
return group->editing;
}
bool lv_group_get_wrap(lv_group_t * group)
{
if(!group) return false;
LV_CHECK_ARG(group != NULL, return false);
return group->wrap;
}
uint32_t lv_group_get_obj_count(lv_group_t * group)
{
LV_ASSERT_NULL(group);
LV_CHECK_ARG(group != NULL, return 0);
return lv_ll_get_len(&group->obj_ll);
}
lv_obj_t * lv_group_get_obj_by_index(lv_group_t * group, uint32_t index)
{
LV_CHECK_ARG(group != NULL, return NULL);
uint32_t len = 0;
lv_obj_t ** obj;
@@ -424,10 +435,7 @@ lv_group_t * lv_group_by_index(uint32_t index)
#if LV_USE_EXT_DATA
void lv_group_set_external_data(lv_group_t * group, void * data, void (* free_cb)(void * data))
{
if(!group) {
LV_LOG_WARN("Can't attach external user data and destructor callback to a NULL group");
return;
}
LV_CHECK_ARG(group != NULL, return);
group->ext_data.data = data;
group->ext_data.free_cb = free_cb;
@@ -436,13 +444,13 @@ void lv_group_set_external_data(lv_group_t * group, void * data, void (* free_cb
void lv_group_set_user_data(lv_group_t * group, void * user_data)
{
if(group == NULL) return;
LV_CHECK_ARG(group != NULL, return);
group->user_data = user_data;
}
void * lv_group_get_user_data(const lv_group_t * group)
{
if(group == NULL) return NULL;
LV_CHECK_ARG(group != NULL, return NULL);
return group->user_data;
}
@@ -467,8 +475,9 @@ static void lv_group_refocus(lv_group_t * g)
static bool focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
void * (*move)(const lv_ll_t *, const void *))
{
if(group->frozen) return false;
bool focus_changed = false;
if(group->frozen) return focus_changed;
lv_obj_t ** obj_next = group->obj_focus;
lv_obj_t ** obj_sentinel = NULL;
src/core/lv_obj.c
+41 -12
View File
@@ -7,6 +7,7 @@
* INCLUDES
*********************/
#include "lv_obj_private.h"
#include "../lv_public_api.h"
#include "../misc/lv_event_private.h"
#include "../misc/lv_area_private.h"
#include "lv_obj_style_private.h"
@@ -223,10 +224,15 @@ const lv_obj_class_t lv_obj_class = {
lv_obj_t * lv_obj_create(lv_obj_t * parent)
{
LV_LOG_INFO("begin");
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
LV_ASSERT_NULL(obj);
if(obj == NULL) return NULL;
lv_obj_class_init_obj(obj);
LV_LOG_TRACE("finished");
return obj;
}
@@ -241,6 +247,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent)
void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(lv_obj_has_flag(obj, f)) /*Check if all flags are set*/
return;
@@ -280,6 +287,7 @@ void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
void lv_obj_remove_flag(lv_obj_t * obj, lv_obj_flag_t f)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_has_flag_any(obj, f))
return;
@@ -402,6 +410,7 @@ lv_group_t * lv_obj_get_group(const lv_obj_t * obj)
lv_result_t lv_obj_add_child(lv_obj_t * parent, lv_obj_t * child)
{
LV_ASSERT_OBJ(parent, MY_CLASS);
LV_CHECK_ARG(child != NULL, return LV_RESULT_INVALID);
uint16_t new_child_cnt = parent->spec_attr->child_cnt + 1;
@@ -421,6 +430,7 @@ void lv_obj_remove_child(lv_obj_t * parent, lv_obj_t * child)
{
LV_ASSERT_OBJ(parent, MY_CLASS);
LV_ASSERT_OBJ(child, MY_CLASS);
for(int32_t i = lv_obj_get_index(child); i < (int32_t)parent->spec_attr->child_cnt - 1; i++) {
parent->spec_attr->children[i] = parent->spec_attr->children[i + 1];
}
@@ -443,6 +453,7 @@ void lv_obj_remove_child(lv_obj_t * parent, lv_obj_t * child)
lv_obj_spec_attr_t * lv_obj_allocate_spec_attr(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr) {
return obj->spec_attr;
}
@@ -462,12 +473,14 @@ lv_obj_spec_attr_t * lv_obj_allocate_spec_attr(lv_obj_t * obj)
bool lv_obj_check_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
{
if(obj == NULL) return false;
LV_CHECK_ARG(obj != NULL, return false);
return obj->class_p == class_p;
}
bool lv_obj_has_class(const lv_obj_t * obj, const lv_obj_class_t * class_p)
{
LV_CHECK_ARG(obj != NULL, return false);
const lv_obj_class_t * obj_class = obj->class_p;
while(obj_class) {
if(obj_class == class_p) return true;
@@ -479,11 +492,14 @@ bool lv_obj_has_class(const lv_obj_t * obj, const lv_obj_class_t * class_p)
const lv_obj_class_t * lv_obj_get_class(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return NULL);
return obj->class_p;
}
bool lv_obj_is_valid(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return false);
lv_display_t * disp = lv_display_get_next(NULL);
while(disp) {
uint32_t i;
@@ -501,18 +517,23 @@ bool lv_obj_is_valid(const lv_obj_t * obj)
void lv_obj_null_on_delete(lv_obj_t ** obj_ptr)
{
LV_CHECK_ARG(obj_ptr != NULL, return);
LV_CHECK_ARG(*obj_ptr != NULL, return);
lv_obj_add_event_cb(*obj_ptr, null_on_delete_cb, LV_EVENT_DELETE, obj_ptr);
}
#if LV_USE_OBJ_ID
void * lv_obj_get_id(const lv_obj_t * obj)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return NULL);
return obj->id;
}
lv_obj_t * lv_obj_find_by_id(const lv_obj_t * obj, const void * id)
{
LV_CHECK_ARG(id != NULL, return NULL);
LV_LOG_WARN("DEPRECATED: IDs are used only to print the widget trees. To find a widget use obj_name");
if(obj == NULL) obj = lv_display_get_screen_active(NULL);
@@ -520,15 +541,13 @@ lv_obj_t * lv_obj_find_by_id(const lv_obj_t * obj, const void * id)
uint32_t i;
uint32_t child_cnt = lv_obj_get_child_count(obj);
for(i = 0; i < child_cnt; i++) {
lv_obj_t * child = obj->spec_attr->children[i];
if(lv_obj_id_compare(child->id, id) == 0) return child;
}
/*Search children*/
for(i = 0; i < child_cnt; i++) {
lv_obj_t * child = obj->spec_attr->children[i];
if(lv_obj_id_compare(child->id, id) == 0) return child;
lv_obj_t * found = lv_obj_find_by_id(child, id);
if(found != NULL) return found;
}
@@ -539,10 +558,8 @@ lv_obj_t * lv_obj_find_by_id(const lv_obj_t * obj, const void * id)
void lv_obj_add_screen_load_event(lv_obj_t * obj, lv_event_code_t trigger, lv_obj_t * screen,
lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay)
{
if(screen == NULL) {
LV_LOG_WARN("`screen` is NULL, can't load a non existing screens");
return;
}
LV_CHECK_ARG(screen != NULL, return, "can't load a non-existing screen");
LV_CHECK_ARG(duration > 0 || anim_type == LV_SCREEN_LOAD_ANIM_NONE, return);
screen_load_anim_dsc_t * dsc = lv_malloc(sizeof(screen_load_anim_dsc_t));
LV_ASSERT_MALLOC(dsc);
@@ -559,6 +576,8 @@ void lv_obj_add_screen_load_event(lv_obj_t * obj, lv_event_code_t trigger, lv_ob
void lv_obj_add_screen_create_event(lv_obj_t * obj, lv_event_code_t trigger, lv_screen_create_cb_t screen_create_cb,
lv_screen_load_anim_t anim_type, uint32_t duration, uint32_t delay)
{
LV_CHECK_ARG(duration > 0 || anim_type == LV_SCREEN_LOAD_ANIM_NONE, return);
screen_load_anim_dsc_t * dsc = lv_malloc(sizeof(screen_load_anim_dsc_t));
LV_ASSERT_MALLOC(dsc);
lv_memzero(dsc, sizeof(screen_load_anim_dsc_t));
@@ -574,6 +593,9 @@ void lv_obj_add_screen_create_event(lv_obj_t * obj, lv_event_code_t trigger, lv_
void lv_obj_add_play_timeline_event(lv_obj_t * obj, lv_event_code_t trigger, lv_anim_timeline_t * at, uint32_t delay,
bool reverse)
{
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(at != NULL, return);
timeline_play_dsc_t * dsc = lv_malloc(sizeof(timeline_play_dsc_t));
LV_ASSERT_MALLOC(dsc);
lv_memzero(dsc, sizeof(timeline_play_dsc_t));
@@ -587,11 +609,14 @@ void lv_obj_add_play_timeline_event(lv_obj_t * obj, lv_event_code_t trigger, lv_
void lv_obj_set_user_data(lv_obj_t * obj, void * user_data)
{
LV_CHECK_ARG(obj != NULL, return);
obj->user_data = user_data;
}
void * lv_obj_get_user_data(lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return NULL);
return obj->user_data;
}
@@ -601,6 +626,8 @@ void * lv_obj_get_user_data(lv_obj_t * obj)
static void lv_obj_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
LV_UNUSED(class_p);
LV_TRACE_OBJ_CREATE("begin");
@@ -636,6 +663,8 @@ static void lv_obj_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
static void lv_obj_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
LV_UNUSED(class_p);
lv_event_mark_deleted(obj);
src/core/lv_obj_class.c
+26 -14
View File
@@ -9,6 +9,7 @@
#include "lv_obj_class_private.h"
#include "lv_obj_private.h"
#include "../display/lv_display_private.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -43,9 +44,12 @@ static uint32_t get_instance_size(const lv_obj_class_t * class_p);
lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * parent)
{
LV_CHECK_ARG(class_p != NULL, return NULL);
LV_TRACE_OBJ_CREATE("Creating object with %p class on %p parent", (void *)class_p, (void *)parent);
uint32_t s = get_instance_size(class_p);
lv_obj_t * obj = lv_malloc_zeroed(s);
LV_ASSERT_MALLOC(obj);
if(obj == NULL) return NULL;
obj->class_p = class_p;
obj->parent = parent;
@@ -67,6 +71,7 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
lv_obj_t ** screens = lv_realloc(disp->screens, sizeof(lv_obj_t *) * (disp->screen_cnt + 1));
LV_ASSERT_MALLOC(screens);
if(screens == NULL) {
LV_LOG_WARN("Failed to expand memory for screen array");
lv_free(obj);
return NULL;
}
@@ -101,7 +106,7 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
void lv_obj_class_init_obj(lv_obj_t * obj)
{
if(obj == NULL) return;
LV_CHECK_ARG(obj != NULL, return);
lv_obj_mark_layout_as_dirty(obj);
lv_obj_enable_style_refresh(false);
@@ -133,6 +138,9 @@ void lv_obj_class_init_obj(lv_obj_t * obj)
void lv_obj_destruct(lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(obj->class_p != NULL, return);
#if LV_USE_EXT_DATA
if(obj->ext_data.free_cb) {
obj->ext_data.free_cb(obj->ext_data.data);
@@ -151,8 +159,10 @@ void lv_obj_destruct(lv_obj_t * obj)
}
}
bool lv_obj_is_editable(lv_obj_t * obj)
bool lv_obj_is_editable(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return false);
const lv_obj_class_t * class_p = obj->class_p;
/*Find a base in which editable is set*/
@@ -163,8 +173,10 @@ bool lv_obj_is_editable(lv_obj_t * obj)
return class_p->editable == LV_OBJ_CLASS_EDITABLE_TRUE;
}
bool lv_obj_is_group_def(lv_obj_t * obj)
bool lv_obj_is_group_def(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return false);
const lv_obj_class_t * class_p = obj->class_p;
/*Find a base in which group_def is set*/
@@ -178,10 +190,7 @@ bool lv_obj_is_group_def(lv_obj_t * obj)
#if LV_USE_EXT_DATA
void lv_obj_set_external_data(lv_obj_t * obj, void * data, void (* free_cb)(void * data))
{
if(!obj) {
LV_LOG_WARN("Can't attach external user data and destructor callback to a NULL object");
return;
}
LV_CHECK_ARG(obj != NULL, return, "Can't attach external user data and destructor callback to a NULL object");
obj->ext_data.data = data;
obj->ext_data.free_cb = free_cb;
@@ -194,9 +203,13 @@ void lv_obj_set_external_data(lv_obj_t * obj, void * data, void (* free_cb)(void
static void lv_obj_construct(const lv_obj_class_t * class_p, lv_obj_t * obj)
{
if(LV_USE_OBJ_NAME) {
LV_ASSERT_NULL(class_p->name);
}
LV_ASSERT_NULL(class_p);
LV_ASSERT_NULL(obj);
LV_ASSERT_NULL(obj->class_p);
#if LV_USE_OBJ_NAME
LV_ASSERT_NULL(class_p->name);
#endif
#if LV_USE_EXT_DATA
obj->ext_data.free_cb = NULL;
@@ -222,10 +235,9 @@ static void lv_obj_construct(const lv_obj_class_t * class_p, lv_obj_t * obj)
static uint32_t get_instance_size(const lv_obj_class_t * class_p)
{
/*Find a base in which instance size is set*/
const lv_obj_class_t * base = class_p;
while(base && base->instance_size == 0) base = base->base_class;
while(class_p && class_p->instance_size == 0) class_p = class_p->base_class;
if(base == NULL) return 0; /*Never happens: set at least in `lv_obj` class*/
LV_ASSERT(class_p != NULL); /*Never happens: set at least in `lv_obj` class*/
return base->instance_size;
return class_p->instance_size;
}
src/core/lv_obj_draw.c
+16
View File
@@ -8,6 +8,7 @@
*********************/
#include "lv_obj_draw_private.h"
#include "lv_obj_private.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -44,6 +45,8 @@ static void drop_shadow_init(const lv_obj_t * obj, lv_part_t part, lv_draw_dsc_b
void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_rect_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -166,6 +169,8 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_rect_dsc_
void lv_obj_init_draw_label_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_label_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -207,6 +212,8 @@ void lv_obj_init_draw_label_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_label_ds
void lv_obj_init_draw_image_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_image_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -249,6 +256,8 @@ void lv_obj_init_draw_image_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_image_ds
void lv_obj_init_draw_line_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_line_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -292,6 +301,8 @@ void lv_obj_init_draw_line_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_line_dsc_
void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_arc_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -330,6 +341,8 @@ void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_arc_dsc_t
void lv_obj_init_draw_blur_dsc(lv_obj_t * obj, lv_part_t part, lv_draw_blur_dsc_t * draw_dsc)
{
LV_CHECK_ARG(draw_dsc != NULL, return);
LV_PROFILER_DRAW_BEGIN;
draw_dsc->base.obj = obj;
draw_dsc->base.part = part;
@@ -420,12 +433,15 @@ void lv_obj_refresh_ext_draw_size(lv_obj_t * obj)
int32_t lv_obj_get_ext_draw_size(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return 0);
if(obj->spec_attr) return obj->spec_attr->ext_draw_size;
else return 0;
}
lv_layer_type_t lv_obj_get_layer_type(const lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return LV_LAYER_TYPE_NONE);
if(obj->spec_attr) return (lv_layer_type_t)obj->spec_attr->layer_type;
else return LV_LAYER_TYPE_NONE;
src/core/lv_obj_event.c
+85 -128
View File
@@ -11,6 +11,7 @@
#include "lv_obj_class_private.h"
#include "lv_obj_private.h"
#include "../indev/lv_indev_private.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -27,6 +28,7 @@
static lv_result_t event_send_core(lv_event_t * e);
static bool event_is_bubbled(lv_event_t * e);
static bool event_is_trickled(lv_event_t * e);
static bool event_code_in_array(lv_event_code_t code, const lv_event_code_t * arr, uint32_t len);
/**********************
* STATIC VARIABLES
@@ -47,7 +49,7 @@ static bool event_is_trickled(lv_event_t * e);
lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * param)
{
if(obj == NULL) return LV_RESULT_OK;
LV_CHECK_ARG(obj != NULL, return LV_RESULT_OK);
LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -75,6 +77,9 @@ lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void *
lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
{
LV_CHECK_ARG(e != NULL, return LV_RESULT_INVALID);
LV_CHECK_ARG(e->current_target != NULL, return LV_RESULT_INVALID);
const lv_obj_class_t * base;
if(class_p == NULL) base = ((lv_obj_t *)e->current_target)->class_p;
else base = class_p->base_class;
@@ -100,7 +105,9 @@ lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
{
LV_CHECK_ARG(event_cb != NULL, return NULL);
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_allocate_spec_attr(obj)) {
return NULL;
}
@@ -110,36 +117,38 @@ lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_
uint32_t lv_obj_get_event_count(lv_obj_t * obj)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return 0);
if(obj->spec_attr == NULL) return 0;
return lv_event_get_count(&obj->spec_attr->event_list);
}
lv_event_dsc_t * lv_obj_get_event_dsc(lv_obj_t * obj, uint32_t index)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return NULL);
if(obj->spec_attr == NULL) return NULL;
return lv_event_get_dsc(&obj->spec_attr->event_list, index);
}
bool lv_obj_remove_event(lv_obj_t * obj, uint32_t index)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return false);
if(obj->spec_attr == NULL) return false;
return lv_event_remove(&obj->spec_attr->event_list, index);
}
bool lv_obj_remove_event_dsc(lv_obj_t * obj, lv_event_dsc_t * dsc)
{
LV_ASSERT_NULL(obj);
LV_ASSERT_NULL(dsc);
LV_CHECK_ARG(obj != NULL, return false);
LV_CHECK_ARG(dsc != NULL, return false);
if(obj->spec_attr == NULL) return false;
return lv_event_remove_dsc(&obj->spec_attr->event_list, dsc);
}
uint32_t lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return 0);
LV_CHECK_ARG(event_cb != NULL, return 0);
uint32_t event_cnt = lv_obj_get_event_count(obj);
uint32_t removed_count = 0;
@@ -160,7 +169,8 @@ uint32_t lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
uint32_t lv_obj_remove_event_cb_with_user_data(lv_obj_t * obj, lv_event_cb_t event_cb, void * user_data)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return 0);
LV_CHECK_ARG(event_cb != NULL, return 0);
uint32_t event_cnt = lv_obj_get_event_count(obj);
uint32_t removed_count = 0;
@@ -191,174 +201,112 @@ lv_obj_t * lv_event_get_target_obj(lv_event_t * e)
lv_indev_t * lv_event_get_indev(lv_event_t * e)
{
if(e->code == LV_EVENT_PRESSED ||
e->code == LV_EVENT_PRESSING ||
e->code == LV_EVENT_PRESS_LOST ||
e->code == LV_EVENT_SHORT_CLICKED ||
e->code == LV_EVENT_LONG_PRESSED ||
e->code == LV_EVENT_LONG_PRESSED_REPEAT ||
e->code == LV_EVENT_CLICKED ||
e->code == LV_EVENT_RELEASED ||
e->code == LV_EVENT_SCROLL_BEGIN ||
e->code == LV_EVENT_SCROLL_END ||
e->code == LV_EVENT_SCROLL ||
e->code == LV_EVENT_GESTURE ||
e->code == LV_EVENT_KEY ||
e->code == LV_EVENT_FOCUSED ||
e->code == LV_EVENT_DEFOCUSED ||
e->code == LV_EVENT_LEAVE ||
e->code == LV_EVENT_HOVER_OVER ||
e->code == LV_EVENT_HOVER_LEAVE) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
static const lv_event_code_t indev_codes[] = {
LV_EVENT_PRESSED, LV_EVENT_PRESSING, LV_EVENT_PRESS_LOST,
LV_EVENT_SHORT_CLICKED, LV_EVENT_LONG_PRESSED, LV_EVENT_LONG_PRESSED_REPEAT,
LV_EVENT_CLICKED, LV_EVENT_RELEASED,
LV_EVENT_SCROLL_BEGIN, LV_EVENT_SCROLL_END, LV_EVENT_SCROLL,
LV_EVENT_GESTURE, LV_EVENT_KEY,
LV_EVENT_FOCUSED, LV_EVENT_DEFOCUSED, LV_EVENT_LEAVE,
LV_EVENT_HOVER_OVER, LV_EVENT_HOVER_LEAVE,
};
LV_CHECK_ARG(event_code_in_array(e->code, indev_codes, sizeof(indev_codes) / sizeof(indev_codes[0])),
return NULL, "invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
lv_layer_t * lv_event_get_layer(lv_event_t * e)
{
if(e->code == LV_EVENT_DRAW_MAIN ||
e->code == LV_EVENT_DRAW_MAIN_BEGIN ||
e->code == LV_EVENT_DRAW_MAIN_END ||
e->code == LV_EVENT_DRAW_POST ||
e->code == LV_EVENT_DRAW_POST_BEGIN ||
e->code == LV_EVENT_DRAW_POST_END) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
static const lv_event_code_t draw_codes[] = {
LV_EVENT_DRAW_MAIN, LV_EVENT_DRAW_MAIN_BEGIN, LV_EVENT_DRAW_MAIN_END,
LV_EVENT_DRAW_POST, LV_EVENT_DRAW_POST_BEGIN, LV_EVENT_DRAW_POST_END,
};
LV_CHECK_ARG(event_code_in_array(e->code, draw_codes, sizeof(draw_codes) / sizeof(draw_codes[0])),
return NULL, "invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
const lv_area_t * lv_event_get_old_size(lv_event_t * e)
{
if(e->code == LV_EVENT_SIZE_CHANGED) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
LV_CHECK_ARG(e->code == LV_EVENT_SIZE_CHANGED, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
uint32_t lv_event_get_key(lv_event_t * e)
{
if(e->code == LV_EVENT_KEY) {
uint32_t * k = lv_event_get_param(e);
if(k) return *k;
else return 0;
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return 0;
}
LV_CHECK_ARG(e->code == LV_EVENT_KEY, return 0,
"invalid event code %" LV_PRId32, (int32_t)e->code);
uint32_t * k = lv_event_get_param(e);
return k ? *k : 0;
}
int32_t lv_event_get_rotary_diff(lv_event_t * e)
{
if(e->code == LV_EVENT_ROTARY) {
int32_t * r = lv_event_get_param(e);
if(r) return *r;
else return 0;
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return 0;
}
LV_CHECK_ARG(e->code == LV_EVENT_ROTARY, return 0,
"invalid event code %" LV_PRId32, (int32_t)e->code);
int32_t * r = lv_event_get_param(e);
return r ? *r : 0;
}
lv_anim_t * lv_event_get_scroll_anim(lv_event_t * e)
{
if(e->code == LV_EVENT_SCROLL_BEGIN) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
LV_CHECK_ARG(e->code == LV_EVENT_SCROLL_BEGIN, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
void lv_event_set_ext_draw_size(lv_event_t * e, int32_t size)
{
if(e->code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
int32_t * cur_size = lv_event_get_param(e);
*cur_size = LV_MAX(*cur_size, size);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
}
LV_CHECK_ARG(e->code == LV_EVENT_REFR_EXT_DRAW_SIZE, return,
"invalid event code %" LV_PRId32, (int32_t)e->code);
int32_t * cur_size = lv_event_get_param(e);
*cur_size = LV_MAX(*cur_size, size);
}
lv_point_t * lv_event_get_self_size_info(lv_event_t * e)
{
if(e->code == LV_EVENT_GET_SELF_SIZE) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return 0;
}
LV_CHECK_ARG(e->code == LV_EVENT_GET_SELF_SIZE, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
lv_hit_test_info_t * lv_event_get_hit_test_info(lv_event_t * e)
{
if(e->code == LV_EVENT_HIT_TEST) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return 0;
}
LV_CHECK_ARG(e->code == LV_EVENT_HIT_TEST, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
const lv_area_t * lv_event_get_cover_area(lv_event_t * e)
{
if(e->code == LV_EVENT_COVER_CHECK) {
lv_cover_check_info_t * p = lv_event_get_param(e);
return p->area;
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
LV_CHECK_ARG(e->code == LV_EVENT_COVER_CHECK, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
lv_cover_check_info_t * p = lv_event_get_param(e);
return p->area;
}
void lv_event_set_cover_res(lv_event_t * e, lv_cover_res_t res)
{
if(e->code == LV_EVENT_COVER_CHECK) {
lv_cover_check_info_t * p = lv_event_get_param(e);
if(res > p->res) p->res = res; /*Save only "stronger" results*/
}
else {
LV_LOG_WARN("Not interpreted with this event code");
}
LV_CHECK_ARG(e->code == LV_EVENT_COVER_CHECK, return,
"invalid event code %" LV_PRId32, (int32_t)e->code);
lv_cover_check_info_t * p = lv_event_get_param(e);
if(res > p->res) p->res = res; /*Save only "stronger" results*/
}
lv_draw_task_t * lv_event_get_draw_task(lv_event_t * e)
{
if(e->code == LV_EVENT_DRAW_TASK_ADDED) {
return lv_event_get_param(e);
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return NULL;
}
LV_CHECK_ARG(e->code == LV_EVENT_DRAW_TASK_ADDED, return NULL,
"invalid event code %" LV_PRId32, (int32_t)e->code);
return lv_event_get_param(e);
}
lv_state_t lv_event_get_prev_state(lv_event_t * e)
{
if(e->code == LV_EVENT_STATE_CHANGED) {
lv_state_t * state = lv_event_get_param(e);
return state ? *state : 0;
}
else {
LV_LOG_WARN("Not interpreted with this event code");
return 0;
}
LV_CHECK_ARG(e->code == LV_EVENT_STATE_CHANGED, return 0,
"invalid event code %" LV_PRId32, (int32_t)e->code);
lv_state_t * state = lv_event_get_param(e);
return state ? *state : 0;
}
/**********************
@@ -490,3 +438,12 @@ static bool event_is_trickled(lv_event_t * e)
return true;
}
}
static bool event_code_in_array(lv_event_code_t code, const lv_event_code_t * arr, uint32_t len)
{
uint32_t i;
for(i = 0; i < len; i++) {
if(code == arr[i]) return true;
}
return false;
}
src/core/lv_obj_id_builtin.c
+9 -6
View File
@@ -9,6 +9,7 @@
#include "lv_obj_class_private.h"
#include "lv_obj_private.h"
#include "lv_global.h"
#include "../lv_public_api.h"
#include "../osal/lv_os_private.h"
/*********************
@@ -44,15 +45,15 @@ typedef struct _class_info_t {
void lv_obj_assign_id(const lv_obj_class_t * class_p, lv_obj_t * obj)
{
LV_ASSERT(obj && class_p);
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(class_p != NULL, return);
uint32_t i;
uint32_t id = 0;
lv_global_t * global = LV_GLOBAL_DEFAULT();
class_info_t * info = NULL;
if(obj == NULL || class_p == NULL) return;
if(global == NULL) return;
LV_ASSERT_NULL(global);
obj->id = NULL;
@@ -80,20 +81,22 @@ void lv_obj_assign_id(const lv_obj_class_t * class_p, lv_obj_t * obj)
void lv_obj_set_id(lv_obj_t * obj, void * id)
{
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return);
if(obj->id) lv_obj_free_id(obj);
obj->id = id;
}
void lv_obj_free_id(lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
obj->id = NULL;
}
const char * lv_obj_stringify_id(lv_obj_t * obj, char * buf, uint32_t len)
{
if(obj == NULL || obj->class_p == NULL) return NULL;
if(buf == NULL) return NULL;
LV_CHECK_ARG(obj != NULL, return NULL);
LV_CHECK_ARG(obj->class_p != NULL, return NULL);
LV_CHECK_ARG(buf != NULL, return NULL);
const char * name = obj->class_p->name;
if(name == NULL) name = "nameless";
src/core/lv_obj_pos.c
+64 -13
View File
@@ -15,6 +15,7 @@
#include "../display/lv_display_private.h"
#include "lv_refr_private.h"
#include "../core/lv_global.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -127,6 +128,9 @@ static int32_t calc_dynamic_width(lv_obj_t * obj, lv_style_prop_t prop, int32_t
int32_t lv_obj_calc_dynamic_width(lv_obj_t * obj, lv_style_prop_t prop)
{
LV_CHECK_ARG(obj != NULL, return 0);
LV_CHECK_ARG(prop == LV_STYLE_WIDTH || prop == LV_STYLE_MIN_WIDTH || prop == LV_STYLE_MAX_WIDTH, return 0);
return calc_dynamic_width(obj, prop, NULL);
}
@@ -170,6 +174,9 @@ static int32_t calc_dynamic_height(lv_obj_t * obj, lv_style_prop_t prop, int32_t
int32_t lv_obj_calc_dynamic_height(lv_obj_t * obj, lv_style_prop_t prop)
{
LV_CHECK_ARG(obj != NULL, return 0);
LV_CHECK_ARG(prop == LV_STYLE_HEIGHT || prop == LV_STYLE_MIN_HEIGHT || prop == LV_STYLE_MAX_HEIGHT, return 0);
return calc_dynamic_height(obj, prop, NULL);
}
@@ -333,6 +340,8 @@ void lv_obj_set_height(lv_obj_t * obj, int32_t h)
void lv_obj_set_content_width(lv_obj_t * obj, int32_t w)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
int32_t left = lv_obj_get_style_space_left(obj, LV_PART_MAIN);
int32_t right = lv_obj_get_style_space_right(obj, LV_PART_MAIN);
lv_obj_set_width(obj, w + left + right);
@@ -340,6 +349,8 @@ void lv_obj_set_content_width(lv_obj_t * obj, int32_t w)
void lv_obj_set_content_height(lv_obj_t * obj, int32_t h)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
int32_t top = lv_obj_get_style_space_top(obj, LV_PART_MAIN);
int32_t bottom = lv_obj_get_style_space_bottom(obj, LV_PART_MAIN);
lv_obj_set_height(obj, h + top + bottom);
@@ -356,6 +367,8 @@ void lv_obj_set_layout(lv_obj_t * obj, uint32_t layout)
bool lv_obj_is_layout_positioned(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(lv_obj_has_flag_any(obj, LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_IGNORE_LAYOUT | LV_OBJ_FLAG_FLOATING)) return false;
lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -368,6 +381,8 @@ bool lv_obj_is_layout_positioned(const lv_obj_t * obj)
void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
obj->layout_inv = 1;
/*Mark the screen as dirty too to mark that there is something to do on this screen*/
@@ -381,6 +396,8 @@ void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
void lv_obj_update_layout(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(update_layout_mutex) {
LV_LOG_TRACE("Already running, returning");
return;
@@ -410,6 +427,7 @@ void lv_obj_set_align(lv_obj_t * obj, lv_align_t align)
void lv_obj_align(lv_obj_t * obj, lv_align_t align, int32_t x_ofs, int32_t y_ofs)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_obj_set_style_align(obj, align, 0);
lv_obj_set_pos(obj, x_ofs, y_ofs);
}
@@ -566,6 +584,7 @@ void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, in
void lv_obj_get_coords(const lv_obj_t * obj, lv_area_t * coords)
{
LV_CHECK_ARG(coords != NULL, return);
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_area_copy(coords, &obj->coords);
@@ -621,11 +640,15 @@ int32_t lv_obj_get_y2(const lv_obj_t * obj)
int32_t lv_obj_get_x_aligned(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
return lv_obj_get_style_x(obj, LV_PART_MAIN);
}
int32_t lv_obj_get_y_aligned(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
return lv_obj_get_style_y(obj, LV_PART_MAIN);
}
@@ -677,6 +700,8 @@ void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area)
int32_t lv_obj_get_self_width(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_point_t p = {0, LV_COORD_MIN};
lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
return p.x;
@@ -684,6 +709,8 @@ int32_t lv_obj_get_self_width(const lv_obj_t * obj)
int32_t lv_obj_get_self_height(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_point_t p = {LV_COORD_MIN, 0};
lv_obj_send_event((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
return p.y;
@@ -787,6 +814,8 @@ bool lv_obj_is_height_max(lv_obj_t * obj)
bool lv_obj_refresh_self_size(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_is_style_any_width_content(obj) && !lv_obj_is_style_any_height_content(obj))
return false;
@@ -806,6 +835,8 @@ bool lv_obj_refresh_self_size(lv_obj_t * obj)
void lv_obj_refr_pos(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(lv_obj_is_layout_positioned(obj)) return;
lv_obj_t * parent = lv_obj_get_parent(obj);
@@ -915,6 +946,8 @@ void lv_obj_refr_pos(lv_obj_t * obj)
void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
/*Convert x and y to absolute coordinates*/
lv_obj_t * parent = obj->parent;
@@ -984,6 +1017,8 @@ void lv_obj_move_to(lv_obj_t * obj, int32_t x, int32_t y)
void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, bool ignore_floating)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
uint32_t i;
uint32_t child_cnt = lv_obj_get_child_count(obj);
for(i = 0; i < child_cnt; i++) {
@@ -1000,30 +1035,36 @@ void lv_obj_move_children_by(lv_obj_t * obj, int32_t x_diff, int32_t y_diff, boo
void lv_obj_transform_point(const lv_obj_t * obj, lv_point_t * p, lv_obj_point_transform_flag_t flags)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(p != NULL, return);
lv_obj_transform_point_array(obj, p, 1, flags);
}
void lv_obj_transform_point_array(const lv_obj_t * obj, lv_point_t points[], size_t count,
lv_obj_point_transform_flag_t flags)
{
if(obj) {
lv_layer_type_t layer_type = lv_obj_get_layer_type(obj);
bool do_tranf = layer_type == LV_LAYER_TYPE_TRANSFORM;
bool recursive = flags & LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE;
bool inverse = flags & LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE;
if(inverse) {
if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
if(do_tranf) transform_point_array(obj, points, count, inverse);
}
else {
if(do_tranf) transform_point_array(obj, points, count, inverse);
if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
}
LV_CHECK_ARG(obj != NULL, return);
lv_layer_type_t layer_type = lv_obj_get_layer_type(obj);
bool do_tranf = layer_type == LV_LAYER_TYPE_TRANSFORM;
bool recursive = flags & LV_OBJ_POINT_TRANSFORM_FLAG_RECURSIVE;
bool inverse = flags & LV_OBJ_POINT_TRANSFORM_FLAG_INVERSE;
if(inverse) {
if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
if(do_tranf) transform_point_array(obj, points, count, inverse);
}
else {
if(do_tranf) transform_point_array(obj, points, count, inverse);
if(recursive) lv_obj_transform_point_array(lv_obj_get_parent(obj), points, count, flags);
}
}
void lv_obj_get_transformed_area(const lv_obj_t * obj, lv_area_t * area, lv_obj_point_transform_flag_t flags)
{
LV_CHECK_ARG(area != NULL, return);
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_point_t p[4] = {
{area->x1, area->y1},
{area->x1, area->y2 + 1},
@@ -1089,6 +1130,7 @@ static lv_obj_tree_walk_res_t blur_walk_cb(lv_obj_t * obj, void * user_data)
lv_result_t lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
{
LV_CHECK_ARG(area != NULL, return LV_RESULT_INVALID);
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_display_t * disp = lv_obj_get_display(obj);
@@ -1124,6 +1166,9 @@ lv_result_t lv_obj_invalidate(const lv_obj_t * obj)
bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
{
LV_CHECK_ARG(area != NULL, return false);
LV_ASSERT_OBJ(obj, MY_CLASS);
if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return false;
/*Invalidate the object only if it belongs to the current or previous or one of the layers'*/
@@ -1201,6 +1246,9 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, int32_t size)
void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area)
{
LV_CHECK_ARG(area != NULL, return);
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_area_copy(area, &obj->coords);
if(obj->spec_attr) {
lv_area_increase(area, obj->spec_attr->ext_click_pad, obj->spec_attr->ext_click_pad);
@@ -1209,6 +1257,9 @@ void lv_obj_get_click_area(const lv_obj_t * obj, lv_area_t * area)
bool lv_obj_hit_test(lv_obj_t * obj, const lv_point_t * point)
{
LV_CHECK_ARG(point != NULL, return false);
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_has_flag(obj, LV_OBJ_FLAG_CLICKABLE)) return false;
lv_area_t a;
src/core/lv_obj_property.c
+16 -1
View File
@@ -9,6 +9,7 @@
#include "lv_obj_private.h"
#include "../misc/lv_utils.h"
#include "lv_obj_class_private.h"
#include "../lv_public_api.h"
#if LV_USE_OBJ_PROPERTY
@@ -105,7 +106,8 @@ static int property_name_compare(const void * ref, const void * element);
lv_result_t lv_obj_set_property(lv_obj_t * obj, const lv_property_t * value)
{
LV_ASSERT(obj && value);
LV_CHECK_ARG(obj != NULL, return LV_RESULT_INVALID);
LV_CHECK_ARG(value != NULL, return LV_RESULT_INVALID);
uint32_t index = LV_PROPERTY_ID_INDEX(value->id);
if(value->id == LV_PROPERTY_ID_INVALID || index > LV_PROPERTY_ID_ANY) {
@@ -123,6 +125,9 @@ lv_result_t lv_obj_set_property(lv_obj_t * obj, const lv_property_t * value)
lv_result_t lv_obj_set_properties(lv_obj_t * obj, const lv_property_t * value, uint32_t count)
{
LV_CHECK_ARG(obj != NULL, return LV_RESULT_INVALID);
LV_CHECK_ARG(value != NULL, return LV_RESULT_INVALID);
for(uint32_t i = 0; i < count; i++) {
lv_result_t result = lv_obj_set_property(obj, &value[i]);
if(result != LV_RESULT_OK) {
@@ -135,6 +140,10 @@ lv_result_t lv_obj_set_properties(lv_obj_t * obj, const lv_property_t * value, u
lv_property_t lv_obj_get_property(lv_obj_t * obj, lv_prop_id_t id)
{
LV_CHECK_ARG(obj != NULL, return (lv_property_t) {
.id = LV_PROPERTY_ID_INVALID
});
lv_result_t result;
lv_property_t value = { 0 };
@@ -162,6 +171,10 @@ lv_property_t lv_obj_get_property(lv_obj_t * obj, lv_prop_id_t id)
lv_property_t lv_obj_get_style_property(lv_obj_t * obj, lv_prop_id_t id, lv_part_t part)
{
LV_CHECK_ARG(obj != NULL, return (lv_property_t) {
.id = LV_PROPERTY_ID_INVALID
});
lv_property_t value;
uint32_t index = LV_PROPERTY_ID_INDEX(id);
@@ -217,6 +230,8 @@ lv_prop_id_t lv_obj_class_property_get_id(const lv_obj_class_t * clz, const char
lv_prop_id_t lv_obj_property_get_id(const lv_obj_t * obj, const char * name)
{
#if LV_USE_OBJ_PROPERTY_NAME
LV_CHECK_ARG(obj != NULL, return LV_PROPERTY_ID_INVALID);
const lv_obj_class_t * clz;
lv_prop_id_t id;
src/core/lv_obj_scroll.c
+54
View File
@@ -10,6 +10,7 @@
#include "../misc/lv_anim_private.h"
#include "lv_obj_private.h"
#include "../indev/lv_indev_scroll.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -71,6 +72,8 @@ void lv_obj_set_scrollbar_mode(lv_obj_t * obj, lv_scrollbar_mode_t mode)
void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_allocate_spec_attr(obj)) {
return;
}
@@ -82,6 +85,8 @@ void lv_obj_set_scroll_dir(lv_obj_t * obj, lv_dir_t dir)
void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_allocate_spec_attr(obj)) {
return;
}
@@ -90,6 +95,8 @@ void lv_obj_set_scroll_snap_x(lv_obj_t * obj, lv_scroll_snap_t align)
void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(!lv_obj_allocate_spec_attr(obj)) {
return;
}
@@ -102,42 +109,56 @@ void lv_obj_set_scroll_snap_y(lv_obj_t * obj, lv_scroll_snap_t align)
lv_scrollbar_mode_t lv_obj_get_scrollbar_mode(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr) return (lv_scrollbar_mode_t) obj->spec_attr->scrollbar_mode;
else return LV_SCROLLBAR_MODE_AUTO;
}
lv_dir_t lv_obj_get_scroll_dir(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr) return (lv_dir_t) obj->spec_attr->scroll_dir;
else return LV_DIR_ALL;
}
lv_scroll_snap_t lv_obj_get_scroll_snap_x(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_x;
else return LV_SCROLL_SNAP_NONE;
}
lv_scroll_snap_t lv_obj_get_scroll_snap_y(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr) return (lv_scroll_snap_t) obj->spec_attr->scroll_snap_y;
else return LV_SCROLL_SNAP_NONE;
}
int32_t lv_obj_get_scroll_x(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr == NULL) return 0;
return -obj->spec_attr->scroll.x;
}
int32_t lv_obj_get_scroll_y(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr == NULL) return 0;
return -obj->spec_attr->scroll.y;
}
int32_t lv_obj_get_scroll_top(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(obj->spec_attr == NULL) return 0;
return -obj->spec_attr->scroll.y;
}
@@ -252,6 +273,9 @@ int32_t lv_obj_get_scroll_right(const lv_obj_t * obj)
void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(end != NULL, return);
lv_anim_t * a;
a = lv_anim_get(obj, scroll_x_anim);
end->x = a ? -a->end_value : lv_obj_get_scroll_x(obj);
@@ -266,6 +290,8 @@ void lv_obj_get_scroll_end(lv_obj_t * obj, lv_point_t * end)
void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(dx == 0 && dy == 0) return;
/*We need to know the final sizes for bound check*/
@@ -314,6 +340,8 @@ void lv_obj_scroll_by_bounded(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_en
void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(dx == 0 && dy == 0) return;
if(anim_en) {
lv_display_t * d = lv_obj_get_display(obj);
@@ -371,12 +399,16 @@ void lv_obj_scroll_by(lv_obj_t * obj, int32_t dx, int32_t dy, lv_anim_enable_t a
void lv_obj_scroll_to(lv_obj_t * obj, int32_t x, int32_t y, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_obj_scroll_to_x(obj, x, anim_en);
lv_obj_scroll_to_y(obj, y, anim_en);
}
void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_anim_delete(obj, scroll_x_anim);
int32_t scroll_x = lv_obj_get_scroll_x(obj);
@@ -387,6 +419,8 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, int32_t x, lv_anim_enable_t anim_en)
void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_anim_delete(obj, scroll_y_anim);
int32_t scroll_y = lv_obj_get_scroll_y(obj);
@@ -397,6 +431,8 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, int32_t y, lv_anim_enable_t anim_en)
void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
/*Be sure the screens layout is correct*/
lv_obj_update_layout(obj);
@@ -406,6 +442,8 @@ void lv_obj_scroll_to_view(lv_obj_t * obj, lv_anim_enable_t anim_en)
void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
/*Be sure the screens layout is correct*/
lv_obj_update_layout(obj);
@@ -421,6 +459,8 @@ void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
if(x == 0 && y == 0) return LV_RESULT_OK;
if(!lv_obj_allocate_spec_attr(obj)) {
@@ -439,6 +479,8 @@ lv_result_t lv_obj_scroll_by_raw(lv_obj_t * obj, int32_t x, int32_t y)
bool lv_obj_is_scrolling(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_indev_t * indev = lv_indev_get_next(NULL);
while(indev) {
if(lv_indev_get_scroll_obj(indev) == obj) return true;
@@ -455,12 +497,16 @@ bool lv_obj_is_scrolling(const lv_obj_t * obj)
void lv_obj_stop_scroll_anim(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_anim_delete((lv_obj_t *)obj, scroll_y_anim);
lv_anim_delete((lv_obj_t *)obj, scroll_x_anim);
}
void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_obj_update_layout(obj);
lv_point_t p;
lv_indev_scroll_get_snap_dist(obj, &p);
@@ -471,6 +517,10 @@ void lv_obj_update_snap(lv_obj_t * obj, lv_anim_enable_t anim_en)
void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t * ver_area)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(hor_area != NULL, return);
LV_CHECK_ARG(ver_area != NULL, return);
lv_area_set(hor_area, 0, 0, -1, -1);
lv_area_set(ver_area, 0, 0, -1, -1);
@@ -647,6 +697,8 @@ void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t *
void lv_obj_scrollbar_invalidate(lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
lv_area_t hor_area;
lv_area_t ver_area;
lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
@@ -659,6 +711,8 @@ void lv_obj_scrollbar_invalidate(lv_obj_t * obj)
void lv_obj_readjust_scroll(lv_obj_t * obj, lv_anim_enable_t anim_en)
{
LV_CHECK_ARG(obj != NULL, return);
/*Be sure the bottom side is not remains scrolled in*/
/*With snapping the content can't be scrolled in*/
if(lv_obj_get_scroll_snap_y(obj) == LV_SCROLL_SNAP_NONE) {
src/core/lv_obj_style.c
+59 -14
View File
@@ -13,6 +13,7 @@
#include "../display/lv_display_private.h"
#include "../core/lv_global.h"
#include "lv_observer_private.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -104,7 +105,9 @@ void lv_obj_style_deinit(void)
void lv_obj_add_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
{
LV_ASSERT(obj->style_cnt < 63);
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(obj->style_cnt < 63, return,
"obj->style_cnt is restricted to 6 bits, so we can't store more than 63 styles");
trans_delete(obj, selector, LV_STYLE_PROP_ANY, NULL);
@@ -164,14 +167,14 @@ void lv_obj_add_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selecto
bool lv_obj_replace_style(lv_obj_t * obj, const lv_style_t * old_style, const lv_style_t * new_style,
lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return false);
LV_CHECK_ARG(old_style != NULL, return false);
LV_CHECK_ARG(new_style != NULL, return false);
LV_CHECK_ARG(old_style != new_style, return false);
lv_state_t state = lv_obj_style_get_selector_state(selector);
lv_part_t part = lv_obj_style_get_selector_part(selector);
/*All objects must exist*/
if(!obj || !old_style || !new_style || (old_style == new_style)) {
return false;
}
/*Similar to lv_obj_add_style, delete transition*/
trans_delete(obj, selector, LV_STYLE_PROP_ANY, NULL);
@@ -209,17 +212,23 @@ bool lv_obj_replace_style(lv_obj_t * obj, const lv_style_t * old_style, const lv
void lv_obj_remove_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return);
remove_style_core(obj, style, selector, false);
}
void lv_obj_remove_theme(lv_obj_t * obj, lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return);
remove_style_core(obj, NULL, selector, true);
}
void lv_obj_remove_style_all(lv_obj_t * obj)
{
lv_obj_remove_style(obj, NULL, LV_PART_ANY | LV_STATE_ANY);
LV_CHECK_ARG(obj != NULL, return);
remove_style_core(obj, NULL, LV_PART_ANY | LV_STATE_ANY, false);
}
void lv_obj_report_style_change(lv_style_t * style)
@@ -286,6 +295,9 @@ void lv_obj_refresh_style(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop)
void lv_obj_style_set_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector, bool dis)
{
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(style != NULL, return);
uint32_t i;
for(i = 0; i < obj->style_cnt; i++) {
if(obj->styles[i].style == style && obj->styles[i].selector == selector) {
@@ -303,6 +315,9 @@ void lv_obj_style_set_disabled(lv_obj_t * obj, const lv_style_t * style, lv_styl
bool lv_obj_style_get_disabled(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return false);
LV_CHECK_ARG(style != NULL, return false);
uint32_t i;
for(i = 0; i < obj->style_cnt; i++) {
if(obj->styles[i].style == style && obj->styles[i].selector == selector) {
@@ -322,7 +337,7 @@ void lv_obj_enable_style_refresh(bool en)
lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop)
{
LV_ASSERT_NULL(obj)
LV_CHECK_ARG(obj != NULL, return lv_style_prop_get_default(prop));
lv_style_selector_t selector = part | obj->state;
lv_style_value_t value_act = { .ptr = NULL };
@@ -336,7 +351,7 @@ lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_
bool lv_obj_has_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, lv_style_prop_t prop)
{
LV_ASSERT_NULL(obj)
LV_CHECK_ARG(obj != NULL, return false);
lv_style_value_t value_act = { .ptr = NULL };
lv_style_res_t found;
@@ -350,6 +365,8 @@ bool lv_obj_has_style_prop(const lv_obj_t * obj, lv_style_selector_t selector, l
void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value,
lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return);
LV_PROFILER_STYLE_BEGIN;
/*Stop running transitions with this property */
@@ -379,6 +396,9 @@ void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_
lv_style_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value,
lv_style_selector_t selector)
{
LV_CHECK_ARG(obj != NULL, return LV_STYLE_RES_NOT_FOUND);
LV_CHECK_ARG(value != NULL, return LV_STYLE_RES_NOT_FOUND);
uint32_t i;
for(i = 0; i < obj->style_cnt; i++) {
if(obj->styles[i].is_local &&
@@ -418,6 +438,9 @@ bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_sty
void lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t prev_state, lv_state_t new_state,
const lv_obj_style_transition_dsc_t * tr_dsc)
{
LV_CHECK_ARG(obj != NULL, return);
LV_CHECK_ARG(tr_dsc != NULL, return);
trans_t * tr;
/*Get the previous and current values*/
@@ -473,7 +496,8 @@ void lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t p
lv_style_value_t lv_obj_style_apply_color_filter(const lv_obj_t * obj, lv_part_t part, lv_style_value_t v)
{
#if LV_USE_COLOR_FILTER
if(obj == NULL) return v;
LV_CHECK_ARG(obj != NULL, return v);
const lv_color_filter_dsc_t * f = lv_obj_get_style_color_filter_dsc(obj, part);
if(f && f->filter_cb) {
lv_opa_t f_opa = lv_obj_get_style_color_filter_opa(obj, part);
@@ -489,6 +513,8 @@ lv_style_value_t lv_obj_style_apply_color_filter(const lv_obj_t * obj, lv_part_t
lv_style_state_cmp_t lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t state1, lv_state_t state2)
{
LV_CHECK_ARG(obj != NULL, return LV_STYLE_STATE_CMP_SAME);
lv_style_state_cmp_t res = LV_STYLE_STATE_CMP_SAME;
/*Are there any new styles for the new state?*/
@@ -550,6 +576,8 @@ lv_style_state_cmp_t lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t state
void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay)
{
LV_CHECK_ARG(obj != NULL, return);
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, obj);
@@ -563,6 +591,8 @@ void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay)
void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay)
{
LV_CHECK_ARG(obj != NULL, return);
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, obj);
@@ -575,6 +605,8 @@ void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay)
lv_text_align_t lv_obj_calculate_style_text_align(const lv_obj_t * obj, lv_part_t part, const char * txt)
{
LV_CHECK_ARG(obj != NULL, return LV_TEXT_ALIGN_AUTO);
lv_text_align_t align = lv_obj_get_style_text_align(obj, part);
lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, part);
lv_bidi_calculate_align(&align, &base_dir, txt);
@@ -583,6 +615,8 @@ lv_text_align_t lv_obj_calculate_style_text_align(const lv_obj_t * obj, lv_part_
lv_opa_t lv_obj_get_style_opa_recursive(const lv_obj_t * obj, lv_part_t part)
{
LV_CHECK_ARG(obj != NULL, return LV_OPA_TRANSP);
LV_PROFILER_STYLE_BEGIN;
lv_opa_t opa_obj = lv_obj_get_style_opa(obj, part);
if(opa_obj <= LV_OPA_MIN) {
@@ -631,6 +665,8 @@ lv_opa_t lv_obj_get_style_opa_recursive(const lv_obj_t * obj, lv_part_t part)
void lv_obj_update_layer_type(lv_obj_t * obj)
{
LV_CHECK_ARG(obj != NULL, return);
lv_layer_type_t layer_type = calculate_layer_type(obj);
if(obj->spec_attr) obj->spec_attr->layer_type = layer_type;
else if(layer_type != LV_LAYER_TYPE_NONE) {
@@ -643,6 +679,10 @@ void lv_obj_update_layer_type(lv_obj_t * obj)
lv_color32_t lv_obj_style_apply_recolor(const lv_obj_t * obj, lv_part_t part, lv_color32_t color)
{
LV_CHECK_ARG(obj != NULL, return (lv_color32_t) {
0
});
lv_opa_t opa = lv_obj_get_style_recolor_opa(obj, part);
if(opa > LV_OPA_TRANSP) {
lv_color_t recolor = lv_obj_get_style_recolor(obj, part);
@@ -654,6 +694,10 @@ lv_color32_t lv_obj_style_apply_recolor(const lv_obj_t * obj, lv_part_t part, lv
lv_color32_t lv_obj_get_style_recolor_recursive(const lv_obj_t * obj, lv_part_t part)
{
LV_CHECK_ARG(obj != NULL, return (lv_color32_t) {
0
});
lv_color32_t result;
lv_color_t color = lv_obj_get_style_recolor(obj, part);
@@ -681,8 +725,9 @@ lv_color32_t lv_obj_get_style_recolor_recursive(const lv_obj_t * obj, lv_part_t
lv_observer_t * lv_obj_bind_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selector_t selector,
lv_subject_t * subject, int32_t ref_value)
{
LV_ASSERT_NULL(subject);
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return NULL);
LV_CHECK_ARG(style != NULL, return NULL);
LV_CHECK_ARG(subject != NULL, return NULL);
if(subject->type != LV_SUBJECT_TYPE_INT) {
LV_LOG_WARN("Subject type must be `int` (was %d)", subject->type);
@@ -710,8 +755,8 @@ lv_observer_t * lv_obj_bind_style(lv_obj_t * obj, const lv_style_t * style, lv_s
lv_observer_t * lv_obj_bind_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_selector_t selector,
lv_subject_t * subject)
{
LV_ASSERT_NULL(subject);
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(obj != NULL, return NULL);
LV_CHECK_ARG(subject != NULL, return NULL);
if(subject->type != LV_SUBJECT_TYPE_INT && subject->type != LV_SUBJECT_TYPE_COLOR &&
subject->type != LV_SUBJECT_TYPE_POINTER) {
src/core/lv_obj_tree.c
+22 -5
View File
@@ -12,6 +12,7 @@
#include "../display/lv_display_private.h"
#include "../misc/lv_anim_private.h"
#include "../core/lv_global.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -52,11 +53,10 @@ static lv_obj_t * lv_obj_get_first_not_deleting_child(lv_obj_t * obj);
void lv_obj_delete(lv_obj_t * obj)
{
if(obj->is_deleting)
return;
if(!obj) return;
if(obj->is_deleting) return;
LV_LOG_TRACE("begin (delete %p)", (void *)obj);
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_obj_invalidate(obj);
lv_obj_t * par = lv_obj_get_parent(obj);
@@ -120,6 +120,8 @@ void lv_obj_clean(lv_obj_t * obj)
void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, obj);
@@ -132,6 +134,8 @@ void lv_obj_delete_delayed(lv_obj_t * obj, uint32_t delay_ms)
void lv_obj_delete_anim_completed_cb(lv_anim_t * a)
{
LV_CHECK_ARG(a != NULL, return);
lv_obj_delete(a->var);
}
@@ -339,6 +343,7 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t idx)
lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(class_p != NULL, return NULL);
if(obj->spec_attr == NULL) return NULL;
@@ -366,6 +371,9 @@ lv_obj_t * lv_obj_get_child_by_type(const lv_obj_t * obj, int32_t idx, const lv_
lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(obj->parent != NULL, return NULL);
lv_obj_t * parent = lv_obj_get_parent(obj);
int32_t sibling_idx = (int32_t)lv_obj_get_index(obj) + idx;
if(sibling_idx < 0) return NULL;
@@ -376,6 +384,8 @@ lv_obj_t * lv_obj_get_sibling(const lv_obj_t * obj, int32_t idx)
lv_obj_t * lv_obj_get_sibling_by_type(const lv_obj_t * obj, int32_t idx, const lv_obj_class_t * class_p)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(obj->parent != NULL, return NULL);
LV_CHECK_ARG(class_p != NULL, return NULL);
lv_obj_t * parent = lv_obj_get_parent(obj);
int32_t sibling_idx = (int32_t)lv_obj_get_index_by_type(obj, class_p) + idx;
@@ -394,6 +404,8 @@ uint32_t lv_obj_get_child_count(const lv_obj_t * obj)
uint32_t lv_obj_get_child_count_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(class_p != NULL, return 0);
if(obj->spec_attr == NULL) return 0;
uint32_t i;
@@ -429,6 +441,7 @@ void lv_obj_set_name(lv_obj_t * obj, const char * name)
void lv_obj_set_name_static(lv_obj_t * obj, const char * name)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(name != NULL, return);
if(!lv_obj_allocate_spec_attr(obj)) {
return;
@@ -450,6 +463,7 @@ const char * lv_obj_get_name(const lv_obj_t * obj)
void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(buf != NULL && buf_size > 0, return);
const char * name = lv_obj_get_name(obj);
/*Use a default name which auto-indexing*/
@@ -516,8 +530,8 @@ void lv_obj_get_name_resolved(const lv_obj_t * obj, char buf[], size_t buf_size)
lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * path)
{
LV_ASSERT_OBJ(parent, MY_CLASS);
if(parent == NULL || parent->spec_attr == NULL || path == NULL) return NULL;
LV_CHECK_ARG(path != NULL, return NULL);
LV_CHECK_ARG(parent->spec_attr != NULL, return NULL);
while(*path) {
const char * segment = path;
@@ -547,6 +561,8 @@ lv_obj_t * lv_obj_get_child_by_name(const lv_obj_t * parent, const char * path)
lv_obj_t * lv_obj_find_by_name(const lv_obj_t * parent, const char * name)
{
LV_CHECK_ARG(name != NULL, return NULL);
if(parent == NULL) parent = lv_display_get_screen_active(NULL);
if(parent == NULL) return NULL;
@@ -587,6 +603,7 @@ int32_t lv_obj_get_index(const lv_obj_t * obj)
int32_t lv_obj_get_index_by_type(const lv_obj_t * obj, const lv_obj_class_t * class_p)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
LV_CHECK_ARG(class_p != NULL, return 0);
lv_obj_t * parent = lv_obj_get_parent(obj);
if(parent == NULL) return 0xFFFFFFFF;
src/core/lv_observer.c
+145 -151
View File
File diff suppressed because it is too large Load Diff
src/core/lv_refr.c
+10 -2
View File
@@ -17,6 +17,7 @@
#include "../draw/lv_draw_private.h"
#include "../draw/opengles/lv_draw_opengles.h"
#include "lv_global.h"
#include "../lv_public_api.h"
/*********************
* DEFINES
@@ -99,6 +100,9 @@ void lv_refr_now(lv_display_t * disp)
void lv_obj_redraw(lv_layer_t * layer, lv_obj_t * obj)
{
LV_CHECK_ARG(layer != NULL, return);
LV_CHECK_ARG(obj != NULL, return);
LV_PROFILER_REFR_BEGIN;
lv_area_t clip_area_ori = layer->_clip_area;
lv_area_t clip_coords_for_obj;
@@ -453,6 +457,9 @@ refr_finish:
*/
lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
{
LV_CHECK_ARG(area_p != NULL, return NULL);
LV_CHECK_ARG(obj != NULL, return NULL);
lv_obj_t * found_p = NULL;
if(lv_area_is_in(area_p, &obj->coords, 0) == false) return NULL;
@@ -490,8 +497,9 @@ lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
void lv_obj_refr(lv_layer_t * layer, lv_obj_t * obj)
{
LV_ASSERT_NULL(layer);
LV_ASSERT_NULL(obj);
LV_CHECK_ARG(layer != NULL, return);
LV_CHECK_ARG(obj != NULL, return);
if(lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) return;
/*If `opa_layered != LV_OPA_COVER` draw the widget on a new layer and blend that layer with the given opacity.*/
src/libs/gltf/gltf_data/lv_gltf_data_injest.cpp
+2 -2
View File
@@ -89,7 +89,7 @@ static void make_small_magenta_texture(uint32_t new_magenta_tex);
template <typename T, typename Func>
static size_t injest_vec_attribute(uint8_t vec_size, int32_t current_attrib_index, lv_gltf_model_t * data,
const fastgltf::Primitive * prim, const char * attrib_id, GLuint primitive_vertex_buffer,
size_t offset, Func &&functor);
size_t offset, Func && functor);
static int32_t injest_get_any_image_index(fastgltf::Optional<fastgltf::Texture> tex);
static bool injest_check_any_image_index_valid(fastgltf::Optional<fastgltf::Texture> tex);
@@ -829,7 +829,7 @@ static bool injest_mesh(lv_gltf_model_t * data, fastgltf::Mesh & mesh)
template <typename T, typename Func>
static size_t injest_vec_attribute(uint8_t vec_size, int32_t current_attrib_index, lv_gltf_model_t * data,
const fastgltf::Primitive * prim, const char * attrib_id, GLuint primitive_vertex_buffer,
size_t offset, Func &&functor
size_t offset, Func && functor
)
{
src/misc/lv_event.c
+1
View File
@@ -484,3 +484,4 @@ static lv_event_dsc_t ** event_array_at(lv_event_list_t * list, uint32_t index)
{
return lv_array_at(&list->array, index);
}
src/misc/lv_ll.c
+2
View File
@@ -41,6 +41,8 @@ static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * nex
void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
{
LV_CHECK_ARG(ll_p != NULL, return);
LV_CHECK_ARG(node_size > 0, return, "cannot initialize a linked list with empty nodes");
ll_p->head = NULL;
ll_p->tail = NULL;
#ifdef LV_ARCH_64