BigW Consortium Gitlab

Skip to content

L
lvgl
Commit f8b4dc3a by Gabor Kiss-Vamosi
Options

merge beta

parents 3a35da8f 9e20b3a1
Showing with 142 additions and 78 deletions
lv_core/lv_indev.c
......@@ -36,6 +36,7 @@ static void indev_keypad_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_button_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_proc_press(lv_indev_proc_t * proc);
static void indev_proc_release(lv_indev_proc_t * proc);
static void indev_proc_reset_query_handler(lv_indev_t * indev);
static lv_obj_t * indev_search_obj(const lv_indev_proc_t * indev, lv_obj_t * obj);
static void indev_drag(lv_indev_proc_t * state);
static void indev_drag_throw(lv_indev_proc_t * state);
......@@ -251,22 +252,13 @@ static void indev_proc_task(void * param)
indev_act = i;
/*Handle reset query before processing the point*/
if(i->proc.reset_query) {
i->proc.act_obj = NULL;
i->proc.last_obj = NULL;
i->proc.drag_range_out = 0;
i->proc.drag_in_prog = 0;
i->proc.long_pr_sent = 0;
i->proc.pr_timestamp = 0;
i->proc.longpr_rep_timestamp = 0;
i->proc.drag_sum.x = 0;
i->proc.drag_sum.y = 0;
i->proc.reset_query = 0;
}
indev_proc_reset_query_handler(i);
if(i->proc.disabled == 0) {
bool more_to_read;
do {
/*Read the data*/
lv_indev_read(i, &data);
more_to_read = lv_indev_read(i, &data);
i->proc.state = data.state;
if(i->proc.state == LV_INDEV_STATE_PR) {
......@@ -282,23 +274,10 @@ static void indev_proc_task(void * param)
else if(i->driver.type == LV_INDEV_TYPE_BUTTON) {
indev_button_proc(i, &data);
}
}
/*Handle reset query if it happened in during processing*/
if(i->proc.reset_query) {
i->proc.act_obj = NULL;
i->proc.last_obj = NULL;
i->proc.drag_range_out = 0;
i->proc.drag_in_prog = 0;
i->proc.long_pr_sent = 0;
i->proc.pr_timestamp = 0;
i->proc.longpr_rep_timestamp = 0;
i->proc.drag_sum.x = 0;
i->proc.drag_sum.y = 0;
i->proc.reset_query = 0;
indev_proc_reset_query_handler(i);
} while(more_to_read);
}
i = lv_indev_next(i); /*Go to the next indev*/
}
......@@ -395,10 +374,12 @@ static void indev_keypad_proc(lv_indev_t * i, lv_indev_data_t * data)
#endif
}
/**
* Process a new point from LV_INDEV_TYPE_BUTTON input device
* @param i pointer to an input device
* @param data pointer to the data read from the input device
* Process new points from a input device. indev->state.pressed has to be set
* @param indev pointer to an input device state
* @param x x coordinate of the next point
* @param y y coordinate of the next point
*/
static void indev_button_proc(lv_indev_t * i, lv_indev_data_t * data)
{
......@@ -571,6 +552,28 @@ static void indev_proc_release(lv_indev_proc_t * proc)
}
/**
* Process a new point from LV_INDEV_TYPE_BUTTON input device
* @param i pointer to an input device
* @param data pointer to the data read from the input device
* Reset input device if a reset query has been sent to it
* @param indev pointer to an input device
*/
static void indev_proc_reset_query_handler(lv_indev_t * indev)
{
if(indev->proc.reset_query) {
indev->proc.act_obj = NULL;
indev->proc.last_obj = NULL;
indev->proc.drag_range_out = 0;
indev->proc.drag_in_prog = 0;
indev->proc.long_pr_sent = 0;
indev->proc.pr_timestamp = 0;
indev->proc.longpr_rep_timestamp = 0;
indev->proc.drag_sum.x = 0;
indev->proc.drag_sum.y = 0;
indev->proc.reset_query = 0;
}
}
/**
* Search the most top, clickable object on the last point of an input device
* @param indev pointer to an input device
* @param obj pointer to a start object, typically the screen
......
lv_misc/lv_anim.c
......@@ -36,7 +36,6 @@ static bool anim_ready_handler(lv_anim_t * a);
**********************/
static lv_ll_t anim_ll;
static uint32_t last_task_run;
static bool anim_del_global_flag = false;
/**********************
* MACROS
......@@ -98,7 +97,6 @@ bool lv_anim_del(void * var, lv_anim_fp_t fp)
lv_ll_rem(&anim_ll, a);
lv_mem_free(a);
del = true;
anim_del_global_flag = true;
}
a = a_next;
......@@ -232,9 +230,8 @@ static bool anim_ready_handler(lv_anim_t * a)
/*Call the callback function at the end*/
/* Check if an animation is deleted in the cb function
* if yes then the caller function has to know this*/
anim_del_global_flag = false;
if(cb != NULL) cb(p);
invalid = anim_del_global_flag;
invalid = true;
}
/*If the animation is not deleted then restart it*/
else {
......
lv_misc/lv_ll.c
......@@ -89,6 +89,36 @@ void * lv_ll_ins_head(lv_ll_t * ll_p)
}
/**
* Insert a new node in front of the n_act node
* @param ll_p pointer to linked list
* @param n_act pointer a node
* @return pointer to the new head
*/
void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
{
lv_ll_node_t* n_new;
lv_ll_node_t* n_prev;
if(NULL == ll_p || NULL == n_act) return NULL;
if(lv_ll_get_head(ll_p) == n_act) {
n_new = lv_ll_ins_head(ll_p);
}
else {
n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE);
lv_mem_assert(n_new);
n_prev = lv_ll_get_prev(ll_p, n_act);
node_set_next(ll_p, n_prev, n_new);
node_set_prev(ll_p, n_new, n_prev);
node_set_prev(ll_p, n_act, n_new);
node_set_next(ll_p, n_new, n_act);
}
return n_new;
}
/**
* Add a new tail to a linked list
* @param ll_p pointer to linked list
* @return pointer to the new tail
......
lv_misc/lv_ll.h
......@@ -56,6 +56,14 @@ void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size);
void * lv_ll_ins_head(lv_ll_t * ll_p);
/**
* Insert a new node in front of the n_act node
* @param ll_p pointer to linked list
* @param n_act pointer a node
* @return pointer to the new head
*/
void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act);
/**
* Add a new tail to a linked list
* @param ll_p pointer to linked list
* @return pointer to the new tail
......
lv_misc/lv_task.c
......@@ -24,7 +24,7 @@
/**********************
* STATIC PROTOTYPES
**********************/
static bool lv_task_exec(lv_task_t* lv_task_p, lv_task_prio_t prio_act);
static bool lv_task_exec (lv_task_t* lv_task_p);
/**********************
* STATIC VARIABLES
......@@ -65,50 +65,47 @@ LV_ATTRIBUTE_TASK_HANDLER void lv_task_handler(void)
handler_start = lv_tick_get();
lv_task_t* lv_task_prio_a[LV_TASK_PRIO_NUM]; /*Lists for all prio.*/
lv_task_prio_t prio_act;
bool prio_reset = false; /*Used to go back to the highest priority*/
lv_task_t* lv_task_next;
/*Init. the lists*/
for(prio_act = LV_TASK_PRIO_LOWEST; prio_act <= LV_TASK_PRIO_HIGHEST; prio_act++) {
lv_task_prio_a[prio_act] = lv_ll_get_head(&lv_task_ll);
/* Run all task from the highest to the lowest priority
* If a lower priority task is executed check task again from the highest priority
* but on the priority of executed tasks don't run tasks before the executed*/
lv_task_t * task_interruper = NULL;
lv_task_t * tmp;
bool end_flag;
do {
end_flag = true;
LL_READ(lv_task_ll,tmp){
/*Here is the interrupter task. Don't execute it again.*/
if(tmp == task_interruper) {
task_interruper = NULL; /*From this point only task after the interrupter comes, so the interrupter is not interesting anymore*/
continue;
}
/*Handle the lv_tasks on all priority*/
for(prio_act = LV_TASK_PRIO_HIGHEST; prio_act > LV_TASK_PRIO_OFF; prio_act --) {
/*Reset the prio. if necessary*/
if(prio_reset != false) {
prio_reset = false;
prio_act = LV_TASK_PRIO_HIGHEST; /*Go again with highest prio */
/*Just try to run the tasks with highest priority.*/
if(tmp->prio == LV_TASK_PRIO_HIGHEST) {
lv_task_exec(tmp);
}
/* Read all lv_task on 'prio_act' but stop on 'prio_reset' */
while(lv_task_prio_a[prio_act] != NULL && prio_reset == false) {
/* Get the next task. (Invalid pointer if a lv_task deletes itself)*/
lv_task_next = lv_ll_get_next(&lv_task_ll, lv_task_prio_a[prio_act]);
/*Execute the current lv_task*/
bool executed = lv_task_exec(lv_task_prio_a[prio_act], prio_act);
if(executed != false) { /*If the task is executed*/
/* During the execution higher priority lv_tasks
* can be ready, so reset the priority if it is not highest*/
if(prio_act != LV_TASK_PRIO_HIGHEST) {
prio_reset = true;
/*Tasks with higher priority then the interrupted shall be run in every case*/
else if(task_interruper) {
if(tmp->prio > task_interruper->prio) {
if(lv_task_exec(tmp)) {
task_interruper = tmp; /*Check all tasks again from the highest priority */
end_flag = false;
break;
}
}
lv_task_prio_a[prio_act] = lv_task_next; /*Load the next task*/
}
/*Reset higher priority lists on 'prio_reset' query*/
if(prio_reset != false) {
for(prio_act = prio_act + 1; prio_act <= LV_TASK_PRIO_HIGHEST; prio_act++) {
lv_task_prio_a[prio_act] = lv_ll_get_head(&lv_task_ll);
/* It is no interrupter task or we already reached it earlier.
* Just run the remaining tasks*/
else {
if(lv_task_exec(tmp)) {
task_interruper = tmp; /*Check all tasks again from the highest priority */
end_flag = false;
break;
}
}
}
} while(!end_flag);
busy_time += lv_tick_elaps(handler_start);
uint32_t idle_period_time = lv_tick_elaps(idle_period_start);
......@@ -134,8 +131,27 @@ LV_ATTRIBUTE_TASK_HANDLER void lv_task_handler(void)
lv_task_t* lv_task_create(void (*task) (void *), uint32_t period, lv_task_prio_t prio, void * param)
{
lv_task_t* new_lv_task;
lv_task_t* tmp;
/*Create task lists in order of priority from high to low*/
tmp = lv_ll_get_head(&lv_task_ll);
if(NULL == tmp) { /*First task*/
new_lv_task = lv_ll_ins_head(&lv_task_ll);
}
else{
do{
if(tmp->prio <= prio){
new_lv_task = lv_ll_ins_prev(&lv_task_ll, tmp);
break;
}
tmp = lv_ll_get_next(&lv_task_ll,tmp);
}while(tmp != NULL);
if(tmp == NULL) { /*Only too high priority tasks were found*/
new_lv_task = lv_ll_ins_tail(&lv_task_ll);
}
}
lv_mem_assert(new_lv_task);
new_lv_task->period = period;
......@@ -146,6 +162,7 @@ lv_task_t* lv_task_create(void (*task) (void *), uint32_t period, lv_task_prio_t
new_lv_task->last_run = lv_tick_get();
return new_lv_task;
}
/**
......@@ -166,7 +183,15 @@ void lv_task_del(lv_task_t* lv_task_p)
*/
void lv_task_set_prio(lv_task_t* lv_task_p, lv_task_prio_t prio)
{
lv_task_p->prio = prio;
/*It's easier to create a new task with the new priority rather then modify the linked list*/
lv_task_t * new_task = lv_task_create(lv_task_p->task, lv_task_p->period, prio, lv_task_p->param);
lv_mem_assert(new_task);
new_task->once = lv_task_p->once;
new_task->last_run = lv_task_p->last_run;
/*Delete the old task*/
lv_ll_rem(&lv_task_ll, lv_task_p);
lv_mem_free(lv_task_p);
}
/**
......@@ -233,15 +258,12 @@ uint8_t lv_task_get_idle(void)
/**
* Execute task if its the priority is appropriate
* @param lv_task_p pointer to lv_task
* @param prio_act the current priority
* @return true: execute, false: not executed
*/
static bool lv_task_exec (lv_task_t* lv_task_p, lv_task_prio_t prio_act)
static bool lv_task_exec (lv_task_t* lv_task_p)
{
bool exec = false;
/*Execute lv_task if its prio is 'prio_act'*/
if(lv_task_p->prio == prio_act) {
/*Execute if at least 'period' time elapsed*/
uint32_t elp = lv_tick_elaps(lv_task_p->last_run);
if(elp >= lv_task_p->period) {
......@@ -253,7 +275,6 @@ static bool lv_task_exec (lv_task_t* lv_task_p, lv_task_prio_t prio_act)
exec = true;
}
}
return exec;
}
......
lv_objx/lv_gauge.c
......@@ -106,7 +106,7 @@ lv_obj_t * lv_gauge_create(lv_obj_t * par, lv_obj_t * copy)
for(i = 0; i < ext->needle_count; i++) {
ext->values[i] = copy_ext->values[i];
}
ext->label_count = copy_ext->label_count;
/*Refresh the style with new signal function*/
lv_obj_refresh_style(new_gauge);
}
......
lv_objx/lv_kb.c
......@@ -186,7 +186,12 @@ void lv_kb_set_cursor_manage(lv_obj_t * kb, bool en)
if(ext->ta) {
lv_cursor_type_t cur_type;
cur_type = lv_ta_get_cursor_type(ext->ta);
if(ext->cursor_mng){
lv_ta_set_cursor_type(ext->ta, cur_type & (~LV_CURSOR_HIDDEN));
}else{
lv_ta_set_cursor_type(ext->ta, cur_type | LV_CURSOR_HIDDEN);
}
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment