adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c4ec7ead5503bd386a9452653d57f354a469d466
tactility/components/lvgl__lvgl/src/misc/lv_event.c
T

405 lines
11 KiB
C
Raw Blame History

/**
* @file lv_event.c
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_event_private.h"
#include "../core/lv_global.h"
#include "../stdlib/lv_mem.h"
#include "lv_assert.h"
#include "lv_types.h"
/*********************
* DEFINES
*********************/
#define event_head LV_GLOBAL_DEFAULT()->event_header
#define event_last_id LV_GLOBAL_DEFAULT()->event_last_register_id
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/* Traverse the list to delete the objects marked for deletion */
static void cleanup_event_list(lv_event_list_t * list);
static void cleanup_event_list_core(lv_array_t * array);
static void event_mark_deleting(lv_event_list_t * list, lv_event_dsc_t * dsc);
static bool event_is_marked_deleting(lv_event_dsc_t * dsc);
static uint32_t event_array_size(lv_event_list_t * list);
static lv_event_dsc_t ** event_array_at(lv_event_list_t * list, uint32_t index);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
#if LV_USE_LOG && LV_LOG_TRACE_EVENT
#define LV_TRACE_EVENT(...) LV_LOG_TRACE(__VA_ARGS__)
#else
#define LV_TRACE_EVENT(...)
#endif
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_event_push(lv_event_t * e)
{
/*Build a simple linked list from the objects used in the events
*It's important to know if this object was deleted by a nested event
*called from this `event_cb`.*/
e->prev = event_head;
event_head = e;
}
void lv_event_pop(lv_event_t * e)
{
event_head = e->prev;
}
lv_result_t lv_event_send(lv_event_list_t * list, lv_event_t * e, bool preprocess)
{
if(list == NULL) return LV_RESULT_OK;
if(e->deleted) return LV_RESULT_INVALID;
/* When obj is deleted in its own event, it will cause the `list->array` header to be released,
* but the content still exists, which leads to memory leakage.
* Therefore, back up the header in advance,
* which can strive to release the memory and prevent used-after-free. */
lv_array_t back_array_head = list->array;
/* Dealing with the problem of nested event deletion event */
const bool is_traversing = list->is_traversing;
list->is_traversing = true;
lv_result_t res = LV_RESULT_OK;
const uint32_t size = event_array_size(list);
for(uint32_t i = 0; i < size && !e->deleted; i++) {
lv_event_dsc_t * dsc = *event_array_at(list, i);
if(dsc->cb == NULL) continue;
if(event_is_marked_deleting(dsc)) continue;
const bool is_preprocessed = (dsc->filter & LV_EVENT_PREPROCESS) != 0;
if(is_preprocessed != preprocess) continue;
lv_event_code_t filter = dsc->filter & ~LV_EVENT_PREPROCESS;
if(filter == LV_EVENT_ALL || filter == e->code) {
e->user_data = dsc->user_data;
dsc->cb(e);
if(e->stop_processing) break;
/*Stop if the object is deleted*/
if(e->deleted) {
res = LV_RESULT_INVALID;
break;
}
}
}
if(is_traversing) return res;
if(e->deleted) cleanup_event_list_core(&back_array_head);
else {
list->is_traversing = false;
cleanup_event_list(list);
}
return res;
}
lv_event_dsc_t * lv_event_add(lv_event_list_t * list, lv_event_cb_t cb, lv_event_code_t filter,
void * user_data)
{
lv_event_dsc_t * dsc = lv_malloc(sizeof(lv_event_dsc_t));
LV_ASSERT_NULL(dsc);
dsc->cb = cb;
dsc->filter = filter;
dsc->user_data = user_data;
if(event_array_size(list) == 0) {
/*event list hasn't been initialized.*/
lv_array_init(&list->array, 1, sizeof(lv_event_dsc_t *));
}
lv_array_push_back(&list->array, &dsc);
return dsc;
}
bool lv_event_remove_dsc(lv_event_list_t * list, lv_event_dsc_t * dsc)
{
LV_ASSERT_NULL(list);
LV_ASSERT_NULL(dsc);
const uint32_t size = event_array_size(list);
for(uint32_t i = 0; i < size; i++) {
lv_event_dsc_t * event = *event_array_at(list, i);
if(event == dsc) {
event_mark_deleting(list, event);
cleanup_event_list(list);
return true;
}
}
return false;
}
uint32_t lv_event_get_count(lv_event_list_t * list)
{
LV_ASSERT_NULL(list);
return event_array_size(list);
}
lv_event_dsc_t * lv_event_get_dsc(lv_event_list_t * list, uint32_t index)
{
LV_ASSERT_NULL(list);
lv_event_dsc_t ** dsc = event_array_at(list, index);
return dsc ? *dsc : NULL;
}
lv_event_cb_t lv_event_dsc_get_cb(lv_event_dsc_t * dsc)
{
LV_ASSERT_NULL(dsc);
return dsc->cb;
}
void * lv_event_dsc_get_user_data(lv_event_dsc_t * dsc)
{
LV_ASSERT_NULL(dsc);
return dsc->user_data;
}
bool lv_event_remove(lv_event_list_t * list, uint32_t index)
{
LV_ASSERT_NULL(list);
lv_event_dsc_t * dsc = lv_event_get_dsc(list, index);
if(dsc == NULL) return false;
event_mark_deleting(list, dsc);
cleanup_event_list(list);
return true;
}
void lv_event_remove_all(lv_event_list_t * list)
{
LV_ASSERT_NULL(list);
const uint32_t size = event_array_size(list);
for(uint32_t i = 0; i < size; i++)
event_mark_deleting(list, *event_array_at(list, i));
cleanup_event_list(list);
}
void * lv_event_get_current_target(lv_event_t * e)
{
return e->current_target;
}
void * lv_event_get_target(lv_event_t * e)
{
return e->original_target;
}
lv_event_code_t lv_event_get_code(lv_event_t * e)
{
return e->code & ~LV_EVENT_PREPROCESS;
}
void * lv_event_get_param(lv_event_t * e)
{
return e->param;
}
void * lv_event_get_user_data(lv_event_t * e)
{
return e->user_data;
}
void lv_event_stop_bubbling(lv_event_t * e)
{
e->stop_bubbling = 1;
}
void lv_event_stop_processing(lv_event_t * e)
{
e->stop_processing = 1;
}
uint32_t lv_event_register_id(void)
{
event_last_id ++;
return event_last_id;
}
void lv_event_mark_deleted(void * target)
{
lv_event_t * e = event_head;
while(e) {
if(e->original_target == target || e->current_target == target) e->deleted = 1;
e = e->prev;
}
}
const char * lv_event_code_get_name(lv_event_code_t code)
{
/*Remove the preprocess flag*/
code &= ~LV_EVENT_PREPROCESS;
#define ENUM_CASE(x) case LV_##x: return #x
switch(code) {
ENUM_CASE(EVENT_ALL);
/** Input device events*/
ENUM_CASE(EVENT_PRESSED);
ENUM_CASE(EVENT_PRESSING);
ENUM_CASE(EVENT_PRESS_LOST);
ENUM_CASE(EVENT_SHORT_CLICKED);
ENUM_CASE(EVENT_SINGLE_CLICKED);
ENUM_CASE(EVENT_DOUBLE_CLICKED);
ENUM_CASE(EVENT_TRIPLE_CLICKED);
ENUM_CASE(EVENT_LONG_PRESSED);
ENUM_CASE(EVENT_LONG_PRESSED_REPEAT);
ENUM_CASE(EVENT_CLICKED);
ENUM_CASE(EVENT_RELEASED);
ENUM_CASE(EVENT_SCROLL_BEGIN);
ENUM_CASE(EVENT_SCROLL_THROW_BEGIN);
ENUM_CASE(EVENT_SCROLL_END);
ENUM_CASE(EVENT_SCROLL);
ENUM_CASE(EVENT_GESTURE);
ENUM_CASE(EVENT_KEY);
ENUM_CASE(EVENT_ROTARY);
ENUM_CASE(EVENT_FOCUSED);
ENUM_CASE(EVENT_DEFOCUSED);
ENUM_CASE(EVENT_LEAVE);
ENUM_CASE(EVENT_HIT_TEST);
ENUM_CASE(EVENT_INDEV_RESET);
ENUM_CASE(EVENT_HOVER_OVER);
ENUM_CASE(EVENT_HOVER_LEAVE);
/** Drawing events*/
ENUM_CASE(EVENT_COVER_CHECK);
ENUM_CASE(EVENT_REFR_EXT_DRAW_SIZE);
ENUM_CASE(EVENT_DRAW_MAIN_BEGIN);
ENUM_CASE(EVENT_DRAW_MAIN);
ENUM_CASE(EVENT_DRAW_MAIN_END);
ENUM_CASE(EVENT_DRAW_POST_BEGIN);
ENUM_CASE(EVENT_DRAW_POST);
ENUM_CASE(EVENT_DRAW_POST_END);
ENUM_CASE(EVENT_DRAW_TASK_ADDED);
/** Special events*/
ENUM_CASE(EVENT_VALUE_CHANGED);
ENUM_CASE(EVENT_INSERT);
ENUM_CASE(EVENT_REFRESH);
ENUM_CASE(EVENT_READY);
ENUM_CASE(EVENT_CANCEL);
/** Other events*/
ENUM_CASE(EVENT_CREATE);
ENUM_CASE(EVENT_DELETE);
ENUM_CASE(EVENT_CHILD_CHANGED);
ENUM_CASE(EVENT_CHILD_CREATED);
ENUM_CASE(EVENT_CHILD_DELETED);
ENUM_CASE(EVENT_SCREEN_UNLOAD_START);
ENUM_CASE(EVENT_SCREEN_LOAD_START);
ENUM_CASE(EVENT_SCREEN_LOADED);
ENUM_CASE(EVENT_SCREEN_UNLOADED);
ENUM_CASE(EVENT_SIZE_CHANGED);
ENUM_CASE(EVENT_STYLE_CHANGED);
ENUM_CASE(EVENT_LAYOUT_CHANGED);
ENUM_CASE(EVENT_GET_SELF_SIZE);
/** Events of optional LVGL components*/
ENUM_CASE(EVENT_INVALIDATE_AREA);
ENUM_CASE(EVENT_RESOLUTION_CHANGED);
ENUM_CASE(EVENT_COLOR_FORMAT_CHANGED);
ENUM_CASE(EVENT_REFR_REQUEST);
ENUM_CASE(EVENT_REFR_START);
ENUM_CASE(EVENT_REFR_READY);
ENUM_CASE(EVENT_RENDER_START);
ENUM_CASE(EVENT_RENDER_READY);
ENUM_CASE(EVENT_FLUSH_START);
ENUM_CASE(EVENT_FLUSH_FINISH);
ENUM_CASE(EVENT_FLUSH_WAIT_START);
ENUM_CASE(EVENT_FLUSH_WAIT_FINISH);
ENUM_CASE(EVENT_VSYNC);
ENUM_CASE(EVENT_VSYNC_REQUEST);
/* Special event flags */
case LV_EVENT_LAST:
case LV_EVENT_PREPROCESS:
case LV_EVENT_MARKED_DELETING:
break;
/* Note that default is not added here because when adding new event code,
* if forget to add case, the compiler will automatically report a warning.
*/
}
#undef ENUM_CASE
return "EVENT_UNKNOWN";
}
/**********************
* STATIC FUNCTIONS
**********************/
static void cleanup_event_list_core(lv_array_t * array)
{
const uint32_t size = lv_array_size(array);
uint32_t kept_count = 0;
for(uint32_t i = 0; i < size; i++) {
lv_event_dsc_t ** dsc_i = lv_array_at(array, i);
lv_event_dsc_t ** dsc_kept = lv_array_at(array, kept_count);
if(event_is_marked_deleting(*dsc_i)) lv_free(*dsc_i);
else {
*dsc_kept = *dsc_i;
kept_count++;
}
}
if(kept_count == 0) lv_array_deinit(array);
else lv_array_resize(array, kept_count);
}
static void cleanup_event_list(lv_event_list_t * list)
{
if(list->is_traversing) return;
if(list->has_marked_deleting == false) return;
cleanup_event_list_core(&list->array);
list->has_marked_deleting = false;
}
static void event_mark_deleting(lv_event_list_t * list, lv_event_dsc_t * dsc)
{
list->has_marked_deleting = true;
dsc->filter |= LV_EVENT_MARKED_DELETING;
}
static bool event_is_marked_deleting(lv_event_dsc_t * dsc)
{
return (dsc->filter & LV_EVENT_MARKED_DELETING) != 0;
}
static uint32_t event_array_size(lv_event_list_t * list)
{
return lv_array_size(&list->array);
}
static lv_event_dsc_t ** event_array_at(lv_event_list_t * list, uint32_t index)
{
return lv_array_at(&list->array, index);
}
Reference in New Issue View Git Blame Copy Permalink