github-code/lvgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LV_INDEV_TYPE_BUTTON added

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2018-02-24 13:17:39 +01:00
parent a676590e30
commit b2f72d3f70
3 changed files with 224 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

325
lv_core/lv_indev.c
View File

@@ -30,9 +30,11 @@
#if LV_INDEV_READ_PERIOD != 0 #if LV_INDEV_READ_PERIOD != 0
static void indev_proc_task(void * param); static void indev_proc_task(void * param);
static void indev_proc_point(lv_indev_proc_t * indev); static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_proc_press(lv_indev_proc_t * info); static void indev_keypad_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_proc_release(lv_indev_proc_t * state); 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 lv_obj_t * indev_search_obj(const lv_indev_proc_t * indev, lv_obj_t * obj); 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(lv_indev_proc_t * state);
static void indev_drag_throw(lv_indev_proc_t * state); static void indev_drag_throw(lv_indev_proc_t * state);
@@ -115,13 +117,13 @@ void lv_indev_enable(lv_hal_indev_type_t type, bool enable)
} }
/** /**
* Set a cursor for a pointer input device * Set a cursor for a pointer input device (for LV_INPUT_TYPE_POINTER and LV_INPUT_TYPE_BUTTON)
* @param indev pointer to an input device (type: 'LV_INDEV_TYPE_POINTER') * @param indev pointer to an input device
* @param cur_obj pointer to an object to be used as cursor * @param cur_obj pointer to an object to be used as cursor
*/ */
void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj) void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj)
{ {
if(indev->driver.type != LV_INDEV_TYPE_POINTER) return; if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) return;
indev->cursor = cur_obj; indev->cursor = cur_obj;
lv_obj_set_parent(indev->cursor, lv_layer_sys()); lv_obj_set_parent(indev->cursor, lv_layer_sys());
@@ -130,47 +132,69 @@ void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj)
#if USE_LV_GROUP #if USE_LV_GROUP
/** /**
* Set a destination group for a keypad input device * Set a destination group for a keypad input device (for LV_INDEV_TYPE_KEYPAD)
* @param indev pointer to an input device (type: 'LV_INDEV_TYPE_KEYPAD') * @param indev pointer to an input device
* @param group point to a group * @param group point to a group
*/ */
void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group) void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group)
{ {
indev->group = group; if(indev->driver.type == LV_INDEV_TYPE_KEYPAD) indev->group = group;
} }
#endif #endif
/** /**
* Get the last point of an input device * Set the an array of points for LV_INDEV_TYPE_BUTTON.
* These points will be assigned to the buttons to press a specific point on the screen
* @param indev pointer to an input device
* @param group point to a group
*/
void lv_indev_set_button_points(lv_indev_t *indev, lv_point_t *points)
{
if(indev->driver.type == LV_INDEV_TYPE_BUTTON) indev->btn_points = points;
}
/**
* Get the last point of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @param point pointer to a point to store the result * @param point pointer to a point to store the result
*/ */
void lv_indev_get_point(lv_indev_t * indev, lv_point_t * point) void lv_indev_get_point(lv_indev_t * indev, lv_point_t * point)
{ {
point->x = indev->proc.act_point.x; if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) {
point->y = indev->proc.act_point.y; point->x = 0;
point->y = 0;
} else {
point->x = indev->proc.act_point.x;
point->y = indev->proc.act_point.y;
}
} }
/** /**
* Check if there is dragging with an input device or not * Check if there is dragging with an input device or not (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @return true: drag is in progress * @return true: drag is in progress
*/ */
bool lv_indev_is_dragging(lv_indev_t * indev) bool lv_indev_is_dragging(lv_indev_t * indev)
{ {
if(indev == NULL) return false; if(indev == NULL) return false;
if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) return false;
return indev->proc.drag_in_prog == 0 ? false : true; return indev->proc.drag_in_prog == 0 ? false : true;
} }
/** /**
* Get the vector of dragging of an input device * Get the vector of dragging of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @param point pointer to a point to store the vector * @param point pointer to a point to store the vector
*/ */
void lv_indev_get_vect(lv_indev_t * indev, lv_point_t * point) void lv_indev_get_vect(lv_indev_t * indev, lv_point_t * point)
{ {
point->x = indev->proc.vect.x; if(indev->driver.type != LV_INDEV_TYPE_POINTER && indev->driver.type != LV_INDEV_TYPE_BUTTON) {
point->y = indev->proc.vect.y; point->x = 0;
point->y = 0;
} else {
point->x = indev->proc.vect.x;
point->y = indev->proc.vect.y;
}
} }
/** /**
@@ -248,41 +272,16 @@ static void indev_proc_task(void * param)
i->last_activity_time = lv_tick_get(); i->last_activity_time = lv_tick_get();
} }
/*Move the cursor if set and moved*/ if(i->driver.type == LV_INDEV_TYPE_POINTER) {
if(i->driver.type == LV_INDEV_TYPE_POINTER && indev_pointer_proc(i,&data);
i->cursor != NULL && }
(i->proc.last_point.x != data.point.x || else if(i->driver.type == LV_INDEV_TYPE_KEYPAD) {
i->proc.last_point.y != data.point.y)) indev_keypad_proc(i, &data);
{ }
lv_obj_set_pos(i->cursor, data.point.x, data.point.y); else if(i->driver.type == LV_INDEV_TYPE_BUTTON) {
indev_button_proc(i, &data);
} }
if(i->driver.type == LV_INDEV_TYPE_POINTER)
{
i->proc.act_point.x = data.point.x;
i->proc.act_point.y = data.point.y;;
/*Process the current point*/
indev_proc_point(&i->proc);
}
else if (i->driver.type == LV_INDEV_TYPE_KEYPAD) {
#if USE_LV_GROUP
if(i->group != NULL && data.key != 0 &&
data.state == LV_INDEV_STATE_PR && i->proc.last_state == LV_INDEV_STATE_REL)
{
if(data.key == LV_GROUP_KEY_NEXT) {
lv_group_focus_next(i->group);
}
else if(data.key == LV_GROUP_KEY_PREV) {
lv_group_focus_prev(i->group);
}
else {
lv_group_send_data(i->group, data.key);
}
}
i->proc.last_state = data.state;
#endif
}
} }
/*Handle reset query if it happened in during processing*/ /*Handle reset query if it happened in during processing*/
@@ -305,52 +304,120 @@ static void indev_proc_task(void * param)
indev_act = NULL; /*End of indev processing, so no act indev*/ indev_act = NULL; /*End of indev processing, so no act indev*/
} }
/** /**
* Process new points from a input device. indev->state.pressed has to be set * Process a new point from LV_INDEV_TYPE_POINTER input device
* @param indev pointer to an input device state * @param i pointer to an input device
* @param x x coordinate of the next point * @param data pointer to the data read from the input device
* @param y y coordinate of the next point
*/ */
static void indev_proc_point(lv_indev_proc_t * indev) static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data)
{ {
if(indev->state == LV_INDEV_STATE_PR){ /*Move the cursor if set and moved*/
#if LV_INDEV_POINT_MARKER != 0 if(i->cursor != NULL &&
lv_area_t area; (i->proc.last_point.x != data->point.x ||
area.x1 = indev->act_point.x - (LV_INDEV_POINT_MARKER >> 1); i->proc.last_point.y != data->point.y))
area.y1 = indev->act_point.y - (LV_INDEV_POINT_MARKER >> 1); {
area.x2 = indev->act_point.x + ((LV_INDEV_POINT_MARKER >> 1) | 0x1); lv_obj_set_pos(i->cursor, data->point.x, data->point.y);
area.y2 = indev->act_point.y + ((LV_INDEV_POINT_MARKER >> 1) | 0x1);
lv_rfill(&area, NULL, LV_COLOR_MAKE(0xFF, 0, 0), LV_OPA_COVER);
#endif
indev_proc_press(indev);
} else {
indev_proc_release(indev);
} }
indev->last_point.x = indev->act_point.x; i->proc.act_point.x = data->point.x;
indev->last_point.y = indev->act_point.y; i->proc.act_point.y = data->point.y;
if(i->proc.state == LV_INDEV_STATE_PR){
#if LV_INDEV_POINT_MARKER != 0
lv_area_t area;
area.x1 = i->proc.act_point.x - (LV_INDEV_POINT_MARKER >> 1);
area.y1 = i->proc.act_point.y - (LV_INDEV_POINT_MARKER >> 1);
area.x2 = i->proc.act_point.x + ((LV_INDEV_POINT_MARKER >> 1) | 0x1);
area.y2 = i->proc.act_point.y + ((LV_INDEV_POINT_MARKER >> 1) | 0x1);
lv_rfill(&area, NULL, LV_COLOR_MAKE(0xFF, 0, 0), LV_OPA_COVER);
#endif
indev_proc_press(&i->proc);
} else {
indev_proc_release(&i->proc);
}
i->proc.last_point.x = i->proc.act_point.x;
i->proc.last_point.y = i->proc.act_point.y;
} }
/** /**
* Process the pressed state * Process a new point from LV_INDEV_TYPE_KEYPAD input device
* @param indev pointer to an input device state * @param i pointer to an input device
* @param data pointer to the data read from the input device
*/ */
static void indev_proc_press(lv_indev_proc_t * info) static void indev_keypad_proc(lv_indev_t * i, lv_indev_data_t * data)
{ {
lv_obj_t * pr_obj = info->act_obj; #if USE_LV_GROUP
if(i->group != NULL && data->key != 0 &&
data->state == LV_INDEV_STATE_PR && i->proc.last_state == LV_INDEV_STATE_REL)
{
if(data->key == LV_GROUP_KEY_NEXT) {
lv_group_focus_next(i->group);
}
else if(data->key == LV_GROUP_KEY_PREV) {
lv_group_focus_prev(i->group);
}
else {
lv_group_send_data(i->group, data->key);
}
}
i->proc.last_state = data->state;
#endif
}
if(info->wait_unil_release != 0) return; /**
* 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
*/
static void indev_button_proc(lv_indev_t * i, lv_indev_data_t * data)
{
i->proc.act_point.x = i->btn_points[data->btn].x;
i->proc.act_point.y = i->btn_points[data->btn].y;
/*Still the same point is pressed*/
if(i->proc.last_point.x == i->proc.act_point.x &&
i->proc.last_point.y == i->proc.act_point.y &&
data->state == LV_INDEV_STATE_PR) {
#if LV_INDEV_POINT_MARKER != 0
lv_area_t area;
area.x1 = i->proc.act_point.x - (LV_INDEV_POINT_MARKER >> 1);
area.y1 = i->proc.act_point.y - (LV_INDEV_POINT_MARKER >> 1);
area.x2 = i->proc.act_point.x + ((LV_INDEV_POINT_MARKER >> 1) | 0x1);
area.y2 = i->proc.act_point.y + ((LV_INDEV_POINT_MARKER >> 1) | 0x1);
lv_rfill(&area, NULL, LV_COLOR_MAKE(0xFF, 0, 0), LV_OPA_COVER);
#endif
indev_proc_press(&i->proc);
} else {
/*If a new point comes always make a release*/
indev_proc_release(&i->proc);
}
i->proc.last_point.x = i->proc.act_point.x;
i->proc.last_point.y = i->proc.act_point.y;
}
/**
* Process the pressed state of LV_INDEV_TYPE_POINER input devices
* @param indev pointer to an input device 'proc'
*/
static void indev_proc_press(lv_indev_proc_t * proc)
{
lv_obj_t * pr_obj = proc->act_obj;
if(proc->wait_unil_release != 0) return;
/*If there is no last object then search*/ /*If there is no last object then search*/
if(info->act_obj == NULL) { if(proc->act_obj == NULL) {
pr_obj = indev_search_obj(info, lv_layer_top()); pr_obj = indev_search_obj(proc, lv_layer_top());
if(pr_obj == NULL) pr_obj = indev_search_obj(info, lv_scr_act()); if(pr_obj == NULL) pr_obj = indev_search_obj(proc, lv_scr_act());
} }
/*If there is last object but it is not dragged and not protected also search*/ /*If there is last object but it is not dragged and not protected also search*/
else if(info->drag_in_prog == 0 && else if(proc->drag_in_prog == 0 &&
lv_obj_is_protected(info->act_obj, LV_PROTECT_PRESS_LOST) == false) {/*Now act_obj != NULL*/ lv_obj_is_protected(proc->act_obj, LV_PROTECT_PRESS_LOST) == false) {/*Now act_obj != NULL*/
pr_obj = indev_search_obj(info, lv_layer_top()); pr_obj = indev_search_obj(proc, lv_layer_top());
if(pr_obj == NULL) pr_obj = indev_search_obj(info, lv_scr_act()); if(pr_obj == NULL) pr_obj = indev_search_obj(proc, lv_scr_act());
} }
/*If a dragable or a protected object was the last then keep it*/ /*If a dragable or a protected object was the last then keep it*/
else { else {
@@ -358,26 +425,26 @@ static void indev_proc_press(lv_indev_proc_t * info)
} }
/*If a new object was found reset some variables and send a pressed signal*/ /*If a new object was found reset some variables and send a pressed signal*/
if(pr_obj != info->act_obj) { if(pr_obj != proc->act_obj) {
info->last_point.x = info->act_point.x; proc->last_point.x = proc->act_point.x;
info->last_point.y = info->act_point.y; proc->last_point.y = proc->act_point.y;
/*If a new object found the previous was lost, so send a signal*/ /*If a new object found the previous was lost, so send a signal*/
if(info->act_obj != NULL) { if(proc->act_obj != NULL) {
info->act_obj->signal_func(info->act_obj, LV_SIGNAL_PRESS_LOST, indev_act); proc->act_obj->signal_func(proc->act_obj, LV_SIGNAL_PRESS_LOST, indev_act);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
} }
if(pr_obj != NULL) { if(pr_obj != NULL) {
/* Save the time when the obj pressed. /* Save the time when the obj pressed.
* It is necessary to count the long press time.*/ * It is necessary to count the long press time.*/
info->pr_timestamp = lv_tick_get(); proc->pr_timestamp = lv_tick_get();
info->long_pr_sent = 0; proc->long_pr_sent = 0;
info->drag_range_out = 0; proc->drag_range_out = 0;
info->drag_in_prog = 0; proc->drag_in_prog = 0;
info->drag_sum.x = 0; proc->drag_sum.x = 0;
info->drag_sum.y = 0; proc->drag_sum.y = 0;
/*Search for 'top' attribute*/ /*Search for 'top' attribute*/
lv_obj_t * i = pr_obj; lv_obj_t * i = pr_obj;
@@ -397,46 +464,46 @@ static void indev_proc_press(lv_indev_proc_t * info)
/*Send a signal about the press*/ /*Send a signal about the press*/
pr_obj->signal_func(pr_obj, LV_SIGNAL_PRESSED, indev_act); pr_obj->signal_func(pr_obj, LV_SIGNAL_PRESSED, indev_act);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
} }
} }
info->act_obj = pr_obj; /*Save the pressed object*/ proc->act_obj = pr_obj; /*Save the pressed object*/
info->last_obj = info->act_obj; /*Refresh the last_obj*/ proc->last_obj = proc->act_obj; /*Refresh the last_obj*/
/*Calculate the vector*/ /*Calculate the vector*/
info->vect.x = info->act_point.x - info->last_point.x; proc->vect.x = proc->act_point.x - proc->last_point.x;
info->vect.y = info->act_point.y - info->last_point.y; proc->vect.y = proc->act_point.y - proc->last_point.y;
/*If there is active object and it can be dragged run the drag*/ /*If there is active object and it can be dragged run the drag*/
if(info->act_obj != NULL) { if(proc->act_obj != NULL) {
info->act_obj->signal_func(info->act_obj, LV_SIGNAL_PRESSING, indev_act); proc->act_obj->signal_func(proc->act_obj, LV_SIGNAL_PRESSING, indev_act);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
indev_drag(info); indev_drag(proc);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
/*If there is no drag then check for long press time*/ /*If there is no drag then check for long press time*/
if(info->drag_in_prog == 0 && info->long_pr_sent == 0) { if(proc->drag_in_prog == 0 && proc->long_pr_sent == 0) {
/*Send a signal about the long press if enough time elapsed*/ /*Send a signal about the long press if enough time elapsed*/
if(lv_tick_elaps(info->pr_timestamp) > LV_INDEV_LONG_PRESS_TIME) { if(lv_tick_elaps(proc->pr_timestamp) > LV_INDEV_LONG_PRESS_TIME) {
pr_obj->signal_func(pr_obj, LV_SIGNAL_LONG_PRESS, indev_act); pr_obj->signal_func(pr_obj, LV_SIGNAL_LONG_PRESS, indev_act);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
/*Mark the signal sending to do not send it again*/ /*Mark the signal sending to do not send it again*/
info->long_pr_sent = 1; proc->long_pr_sent = 1;
/*Save the long press time stamp for the long press repeat handler*/ /*Save the long press time stamp for the long press repeat handler*/
info->longpr_rep_timestamp = lv_tick_get(); proc->longpr_rep_timestamp = lv_tick_get();
} }
} }
/*Send long press repeated signal*/ /*Send long press repeated signal*/
if(info->drag_in_prog == 0 && info->long_pr_sent == 1) { if(proc->drag_in_prog == 0 && proc->long_pr_sent == 1) {
/*Send a signal about the long press repeate if enough time elapsed*/ /*Send a signal about the long press repeate if enough time elapsed*/
if(lv_tick_elaps(info->longpr_rep_timestamp) > LV_INDEV_LONG_PRESS_REP_TIME) { if(lv_tick_elaps(proc->longpr_rep_timestamp) > LV_INDEV_LONG_PRESS_REP_TIME) {
pr_obj->signal_func(pr_obj, LV_SIGNAL_LONG_PRESS_REP, indev_act); pr_obj->signal_func(pr_obj, LV_SIGNAL_LONG_PRESS_REP, indev_act);
if(info->reset_query != 0) return; if(proc->reset_query != 0) return;
info->longpr_rep_timestamp = lv_tick_get(); proc->longpr_rep_timestamp = lv_tick_get();
} }
} }
@@ -444,33 +511,33 @@ static void indev_proc_press(lv_indev_proc_t * info)
} }
/** /**
* Process the released state * Process the released state of LV_INDEV_TYPE_POINER input devices
* @param indev_proc_p pointer to an input device state * @param proc pointer to an input device 'proc'
*/ */
static void indev_proc_release(lv_indev_proc_t * state) static void indev_proc_release(lv_indev_proc_t * proc)
{ {
if(state->wait_unil_release != 0) { if(proc->wait_unil_release != 0) {
state->act_obj = NULL; proc->act_obj = NULL;
state->last_obj = NULL; proc->last_obj = NULL;
state->pr_timestamp = 0; proc->pr_timestamp = 0;
state->longpr_rep_timestamp = 0; proc->longpr_rep_timestamp = 0;
state->wait_unil_release = 0; proc->wait_unil_release = 0;
} }
/*Forgot the act obj and send a released signal */ /*Forgot the act obj and send a released signal */
if(state->act_obj != NULL) { if(proc->act_obj != NULL) {
state->act_obj->signal_func(state->act_obj, LV_SIGNAL_RELEASED, indev_act); proc->act_obj->signal_func(proc->act_obj, LV_SIGNAL_RELEASED, indev_act);
if(state->reset_query != 0) return; if(proc->reset_query != 0) return;
state->act_obj = NULL; proc->act_obj = NULL;
state->pr_timestamp = 0; proc->pr_timestamp = 0;
state->longpr_rep_timestamp = 0; proc->longpr_rep_timestamp = 0;
} }
/*The reset can be set in the signal function. /*The reset can be set in the signal function.
* In case of reset query ignore the remaining parts.*/ * In case of reset query ignore the remaining parts.*/
if(state->last_obj != NULL && state->reset_query == 0) { if(proc->last_obj != NULL && proc->reset_query == 0) {
indev_drag_throw(state); indev_drag_throw(proc);
if(state->reset_query != 0) return; if(proc->reset_query != 0) return;
} }
} }

25
lv_core/lv_indev.h
View File

@@ -60,40 +60,49 @@ void lv_indev_reset_lpr(lv_indev_t * indev);
void lv_indev_enable(lv_hal_indev_type_t type, bool enable); void lv_indev_enable(lv_hal_indev_type_t type, bool enable);
/** /**
* Set a cursor for a pointer input device * Set a cursor for a pointer input device (for LV_INPUT_TYPE_POINTER and LV_INPUT_TYPE_BUTTON)
* @param indev pointer to an input device (type: 'LV_INDEV_TYPE_POINTER') * @param indev pointer to an input device
* @param cur_obj pointer to an object to be used as cursor * @param cur_obj pointer to an object to be used as cursor
*/ */
void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj); void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj);
#if USE_LV_GROUP #if USE_LV_GROUP
/** /**
* Set a destination group for a keypad input device * Set a destination group for a keypad input device (for LV_INDEV_TYPE_KEYPAD)
* @param indev pointer to an input device (type: 'LV_INDEV_TYPE_KEYPAD') * @param indev pointer to an input device
* @param group point to a group * @param group point to a group
*/ */
void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group); void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group);
#endif #endif
/** /**
* Get the last point of an input device * Set the an array of points for LV_INDEV_TYPE_BUTTON.
* These points will be assigned to the buttons to press a specific point on the screen
* @param indev pointer to an input device
* @param group point to a group
*/
void lv_indev_set_button_points(lv_indev_t *indev, lv_point_t *points);
/**
* Get the last point of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @param point pointer to a point to store the result * @param point pointer to a point to store the result
*/ */
void lv_indev_get_point(lv_indev_t * indev, lv_point_t * point); void lv_indev_get_point(lv_indev_t * indev, lv_point_t * point);
/** /**
* Check if there is dragging with an input device or not * Check if there is dragging with an input device or not (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @return true: drag is in progress * @return true: drag is in progress
*/ */
bool lv_indev_is_dragging(lv_indev_t * indev); bool lv_indev_is_dragging(lv_indev_t * indev);
/** /**
* Get the vector of dragging of an input device * Get the vector of dragging of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
* @param indev pointer to an input device * @param indev pointer to an input device
* @param point pointer to a point to store the vector * @param point pointer to a point to store the vector
*/ */
void lv_indev_get_vect(lv_indev_t * indev, lv_point_t * point); void lv_indev_get_vect(lv_indev_t * indev, lv_point_t * point);
/** /**
* Get elapsed time since last press * Get elapsed time since last press
* @param indev pointer to an input device (NULL to get the overall smallest inactivity) * @param indev pointer to an input device (NULL to get the overall smallest inactivity)

22
lv_hal/lv_hal_indev.h
View File

@@ -33,22 +33,24 @@ typedef enum {
LV_INDEV_TYPE_NONE, /*Show uninitialized state*/ LV_INDEV_TYPE_NONE, /*Show uninitialized state*/
LV_INDEV_TYPE_POINTER, /*Touch pad, mouse, external button*/ LV_INDEV_TYPE_POINTER, /*Touch pad, mouse, external button*/
LV_INDEV_TYPE_KEYPAD, /*Keypad or keyboard*/ LV_INDEV_TYPE_KEYPAD, /*Keypad or keyboard*/
LV_INDEV_TYPE_BUTTON, /*External (hardware button) which is assinged to a specific point of the screen*/
} lv_hal_indev_type_t; } lv_hal_indev_type_t;
/*States for input devices*/ /*States for input devices*/
typedef enum { typedef enum {
LV_INDEV_STATE_REL, LV_INDEV_STATE_REL = 0,
LV_INDEV_STATE_PR LV_INDEV_STATE_PR
}lv_indev_state_t; }lv_indev_state_t;
/*Data type when an input device is read */ /*Data type when an input device is read */
typedef struct { typedef struct {
union { union {
lv_point_t point; /*For INDEV_TYPE_POINTER*/ lv_point_t point; /*For LV_INDEV_TYPE_POINTER the currently pressed point*/
uint32_t key; /*For INDEV_TYPE_KEYPAD*/ uint32_t key; /*For LV_INDEV_TYPE_KEYPAD the currently pressed key*/
uint32_t btn; /*For LV_INDEV_TYPE_BUTTON the currently pressed button*/
}; };
lv_indev_state_t state; /*LV_INDEV_EVENT_REL or LV_INDEV_EVENT_PR*/ lv_indev_state_t state; /*LV_INDEV_EVENT_REL or LV_INDEV_EVENT_PR*/
void *user_data; /*'lv_indev_drv_t.priv' for this driver*/ void *user_data; /*'lv_indev_drv_t.priv' for this driver*/
}lv_indev_data_t; }lv_indev_data_t;
/*Initialized by the user and registered by 'lv_indev_add()'*/ /*Initialized by the user and registered by 'lv_indev_add()'*/
@@ -60,10 +62,11 @@ typedef struct {
struct _lv_obj_t; struct _lv_obj_t;
typedef struct _lv_indev_state_t { /*Run time data of input devices*/
typedef struct _lv_indev_proc_t {
lv_indev_state_t state; lv_indev_state_t state;
union { union {
struct { /*Pointer data*/ struct { /*Pointer and button data*/
lv_point_t act_point; lv_point_t act_point;
lv_point_t last_point; lv_point_t last_point;
lv_point_t vect; lv_point_t vect;
@@ -94,13 +97,16 @@ typedef struct _lv_indev_state_t {
struct _lv_obj_t; struct _lv_obj_t;
struct _lv_group_t; struct _lv_group_t;
/*The main input device descriptor with driver, runtime data ('proc') and some additional information*/
typedef struct _lv_indev_t { typedef struct _lv_indev_t {
lv_indev_drv_t driver; lv_indev_drv_t driver;
lv_indev_proc_t proc; lv_indev_proc_t proc;
uint32_t last_activity_time; uint32_t last_activity_time;
union { union {
struct _lv_obj_t *cursor; struct _lv_obj_t *cursor; /*Cursor for LV_INPUT_TYPE_POINTER*/
struct _lv_group_t *group; /*Keypad destination group*/ struct _lv_group_t *group; /*Keypad destination group*/
lv_point_t * btn_points; /*Array points assigned to the button ()screen will be pressed here by the buttons*/
}; };
struct _lv_indev_t *next; struct _lv_indev_t *next;
} lv_indev_t; } lv_indev_t;