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

remove btnm, mbox, kb, tabview actions

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2019-03-12 06:20:45 +01:00
parent 2bf4e080e4
commit 4b3859f949
11 changed files with 319 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
lv_core/lv_obj.c
View File

@@ -190,6 +190,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
new_obj->opa_scale_en = 0; new_obj->opa_scale_en = 0;
new_obj->protect = LV_PROTECT_NONE; new_obj->protect = LV_PROTECT_NONE;
new_obj->opa_scale = LV_OPA_COVER; new_obj->opa_scale = LV_OPA_COVER;
new_obj->parent_event = 0;
new_obj->ext_attr = NULL; new_obj->ext_attr = NULL;
@@ -299,6 +300,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
new_obj->drag_parent = copy->drag_parent; new_obj->drag_parent = copy->drag_parent;
new_obj->hidden = copy->hidden; new_obj->hidden = copy->hidden;
new_obj->top = copy->top; new_obj->top = copy->top;
new_obj->parent_event = copy->parent_event;
new_obj->opa_scale_en = copy->opa_scale_en; new_obj->opa_scale_en = copy->opa_scale_en;
new_obj->protect = copy->protect; new_obj->protect = copy->protect;
@@ -1104,6 +1106,16 @@ void lv_obj_set_drag_parent(lv_obj_t * obj, bool en)
obj->drag_parent = (en == true ? 1 : 0); obj->drag_parent = (en == true ? 1 : 0);
} }
/**
* Propagate the events to the parent too
* @param obj pointer to an object
* @param en true: enable the event propagation
*/
void lv_obj_set_parent_event(lv_obj_t * obj, bool en)
{
obj->parent_event = (en == true ? 1 : 0);
}
/** /**
* Set the opa scale enable parameter (required to set opa_scale with `lv_obj_set_opa_scale()`) * Set the opa scale enable parameter (required to set opa_scale with `lv_obj_set_opa_scale()`)
* @param obj pointer to an object * @param obj pointer to an object
@@ -1174,7 +1186,7 @@ lv_res_t lv_obj_send_event(lv_obj_t * obj, lv_event_t event)
if(obj_act_event_deleted) return LV_RES_INV; if(obj_act_event_deleted) return LV_RES_INV;
if(obj->event_parent && obj->par) { if(obj->parent_event && obj->par) {
lv_res_t res = lv_obj_send_event(obj->par, event); lv_res_t res = lv_obj_send_event(obj->par, event);
if(res != LV_RES_OK) return LV_RES_INV; if(res != LV_RES_OK) return LV_RES_INV;
} }
@@ -1638,6 +1650,16 @@ bool lv_obj_get_drag_parent(const lv_obj_t * obj)
return obj->drag_parent == 0 ? false : true; return obj->drag_parent == 0 ? false : true;
} }
/**
* Get the drag parent attribute of an object
* @param obj pointer to an object
* @return true: drag parent is enabled
*/
bool lv_obj_get_parent_event(const lv_obj_t * obj)
{
return obj->parent_event == 0 ? false : true;
}
/** /**
* Get the opa scale enable parameter * Get the opa scale enable parameter
* @param obj pointer to an object * @param obj pointer to an object

15
lv_core/lv_obj.h
View File

@@ -192,7 +192,7 @@ typedef struct _lv_obj_t
uint8_t hidden :1; /*1: Object is hidden*/ uint8_t hidden :1; /*1: Object is hidden*/
uint8_t top :1; /*1: If the object or its children is clicked it goes to the foreground*/ uint8_t top :1; /*1: If the object or its children is clicked it goes to the foreground*/
uint8_t opa_scale_en :1; /*1: opa_scale is set*/ uint8_t opa_scale_en :1; /*1: opa_scale is set*/
uint8_t event_parent :1; /*1: Send the object's events to the parent too. */ uint8_t parent_event :1; /*1: Send the object's events to the parent too. */
uint8_t protect; /*Automatically happening actions can be prevented. 'OR'ed values from `lv_protect_t`*/ uint8_t protect; /*Automatically happening actions can be prevented. 'OR'ed values from `lv_protect_t`*/
lv_opa_t opa_scale; /*Scale down the opacity by this factor. Effects all children as well*/ lv_opa_t opa_scale; /*Scale down the opacity by this factor. Effects all children as well*/
@@ -454,12 +454,11 @@ void lv_obj_set_drag_throw(lv_obj_t * obj, bool en);
void lv_obj_set_drag_parent(lv_obj_t * obj, bool en); void lv_obj_set_drag_parent(lv_obj_t * obj, bool en);
/** /**
* Set editable parameter Used by groups and keyboard/encoder control. * Propagate the events to the parent too
* Editable object has something inside to choose (the elements of a list)
* @param obj pointer to an object * @param obj pointer to an object
* @param en true: enable editing * @param en true: enable the event propagation
*/ */
//void lv_obj_set_editable(lv_obj_t * obj, bool en); void lv_obj_set_parent_event(lv_obj_t * obj, bool en);
/** /**
* Set the opa scale enable parameter (required to set opa_scale with `lv_obj_set_opa_scale()`) * Set the opa scale enable parameter (required to set opa_scale with `lv_obj_set_opa_scale()`)
@@ -721,6 +720,12 @@ bool lv_obj_get_drag_throw(const lv_obj_t * obj);
*/ */
bool lv_obj_get_drag_parent(const lv_obj_t * obj); bool lv_obj_get_drag_parent(const lv_obj_t * obj);
/**
* Get the drag parent attribute of an object
* @param obj pointer to an object
* @return true: drag parent is enabled
*/
bool lv_obj_get_parent_event(const lv_obj_t * obj);
/** /**
* Get the opa scale enable parameter * Get the opa scale enable parameter

3
lv_misc/lv_txt.c
View File

@@ -437,7 +437,7 @@ static uint8_t lv_txt_utf8_size(const char * str)
else if((str[0] & 0xE0) == 0xC0) return 2; else if((str[0] & 0xE0) == 0xC0) return 2;
else if((str[0] & 0xF0) == 0xE0) return 3; else if((str[0] & 0xF0) == 0xE0) return 3;
else if((str[0] & 0xF8) == 0xF0) return 4; else if((str[0] & 0xF8) == 0xF0) return 4;
return 0; return 1; /*If the char was invalid step tell it's 1 byte long*/
} }
@@ -616,7 +616,6 @@ static uint32_t lv_txt_utf8_get_byte_id(const char * txt, uint32_t utf8_id)
} }
return byte_cnt; return byte_cnt;
} }

167
lv_objx/lv_btnm.c
View File

@@ -43,7 +43,7 @@ static bool maps_are_identical(const char ** map1, const char ** map2);
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static const char * lv_btnm_def_map[] = {"Btn1", "Btn2", "Btn3", "\n", static const char * lv_btnm_def_map[] = {"Btn1", "Btn2", "Btn3", "\n",
"\002Btn4", "Btn5", "" "Btn4", "Btn5", ""
}; };
static lv_design_cb_t ancestor_design_f; static lv_design_cb_t ancestor_design_f;
@@ -80,7 +80,7 @@ lv_obj_t * lv_btnm_create(lv_obj_t * par, const lv_obj_t * copy)
if(ext == NULL) return NULL; if(ext == NULL) return NULL;
ext->btn_cnt = 0; ext->btn_cnt = 0;
ext->btn_id_pr = LV_BTNM_PR_NONE; ext->btn_id_pr = LV_BTNM_BTN_NONE;
ext->button_areas = NULL; ext->button_areas = NULL;
ext->ctrl_bits = NULL; ext->ctrl_bits = NULL;
ext->map_p = NULL; ext->map_p = NULL;
@@ -277,13 +277,13 @@ void lv_btnm_set_ctrl_map(const lv_obj_t * btnm, const lv_btnm_ctrl_t * ctrl_map
* Set the pressed button i.e. visually highlight it. * Set the pressed button i.e. visually highlight it.
* Mainly used a when the btnm is in a group to show the selected button * Mainly used a when the btnm is in a group to show the selected button
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param id index of the currently pressed button (`LV_BTNM_PR_NONE` to unpress) * @param id index of the currently pressed button (`LV_BTNM_BTN_NONE` to unpress)
*/ */
void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id) void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (id >= ext->btn_cnt && id != LV_BTNM_PR_NONE) if (id >= ext->btn_cnt && id != LV_BTNM_BTN_NONE)
return; return;
if (id == ext->btn_id_pr) if (id == ext->btn_id_pr)
@@ -354,10 +354,8 @@ void lv_btnm_set_btn_hidden(const lv_obj_t * btnm, uint16_t btn_idx, bool hidden
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_idx >= ext->btn_cnt) return; if (btn_idx >= ext->btn_cnt) return;
if (hidden) if (hidden) ext->ctrl_bits[btn_idx] |= LV_BTNM_BTN_HIDDEN;
ext->ctrl_bits[btn_idx] |= LV_BTNM_BTN_HIDDEN; else ext->ctrl_bits[btn_idx] &= (~LV_BTNM_BTN_HIDDEN);
else
ext->ctrl_bits[btn_idx] &= (~LV_BTNM_BTN_HIDDEN);
invalidate_button_area(btnm, btn_idx); invalidate_button_area(btnm, btn_idx);
} }
@@ -366,14 +364,14 @@ void lv_btnm_set_btn_hidden(const lv_obj_t * btnm, uint16_t btn_idx, bool hidden
* Enable/disable a single button in the matrix * Enable/disable a single button in the matrix
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param disabled true: disable the button * @param ina true: make the button inactive
*/ */
void lv_btnm_set_btn_inactive(const lv_obj_t * btnm, uint16_t btn_id, bool disabled) void lv_btnm_set_btn_inactive(const lv_obj_t * btnm, uint16_t btn_id, bool ina)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_id >= ext->btn_cnt) return; if (btn_id >= ext->btn_cnt) return;
if (disabled)ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_INACTIVE; if (ina) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_INACTIVE;
else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_INACTIVE); else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_INACTIVE);
invalidate_button_area(btnm, btn_id); invalidate_button_area(btnm, btn_id);
@@ -383,46 +381,58 @@ void lv_btnm_set_btn_inactive(const lv_obj_t * btnm, uint16_t btn_id, bool disab
* Enable/disable long press for a single button in the matrix * Enable/disable long press for a single button in the matrix
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param disabled true: disable repeat * @param no_rep true: disable repeat
*/ */
void lv_btnm_set_btn_no_repeat(const lv_obj_t * btnm, uint16_t btn_id, bool disabled) void lv_btnm_set_btn_no_repeat(const lv_obj_t * btnm, uint16_t btn_id, bool no_rep)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_id >= ext->btn_cnt) return; if (btn_id >= ext->btn_cnt) return;
if (disabled) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_NO_REPEAT; if (no_rep) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_NO_REPEAT;
else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_NO_REPEAT); else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_NO_REPEAT);
}
invalidate_button_area(btnm, btn_id); /**
* Enable/disable toggling a single button in the matrix
* @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify.
* @param tgl true: toggle enable
*/
void lv_btnm_set_btn_toggle(const lv_obj_t * btnm, uint16_t btn_id, bool tgl)
{
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_id >= ext->btn_cnt) return;
if (tgl) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_TOGGLE;
else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_TOGGLE);
} }
/** /**
* Make the a single button button toggled or not toggled. * Make the a single button button toggled or not toggled.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id index of button (not counting "\n") * @param btn_id index of button (not counting "\n")
* @param en true: enable toggling; false: disable toggling * @param state true: toggled; false: not toggled
*/ */
void lv_btnm_set_btn_toggle_state(lv_obj_t * btnm, uint16_t btn_id, bool toggle) void lv_btnm_set_btn_toggle_state(lv_obj_t * btnm, uint16_t btn_id, bool state)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_id >= ext->btn_cnt) return; if (btn_id >= ext->btn_cnt) return;
if(toggle) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_TOGGLE_STATE; if(state) ext->ctrl_bits[btn_id] |= LV_BTNM_BTN_TOGGLE_STATE;
else ext->ctrl_bits[btn_id] &= LV_BTNM_BTN_TOGGLE_STATE; else ext->ctrl_bits[btn_id] &= (~LV_BTNM_BTN_TOGGLE_STATE);
invalidate_button_area(btnm, btn_id); invalidate_button_area(btnm, btn_id);
lv_obj_invalidate(btnm);
} }
/** /**
* Set hidden/disabled/repeat flags for a single button. * Set hidden/disabled/repeat flags for a single button.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_idx 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param hidden true: hide the button * @param hidden true: hide the button
* @param disabled true: disable the button * @param inactive true: disable the button
* @param disable_repeat true: disable repeat * @param no_repeat true: disable repeat
* @param toggle true: enable toggling
* @param toggled_state true: set toggled state
*/ */
void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden, bool disabled, bool disable_repeat, bool toggle, bool toggle_state) void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden, bool inactive, bool no_repeat, bool toggle, bool toggle_state)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if (btn_id >= ext->btn_cnt) return; if (btn_id >= ext->btn_cnt) return;
@@ -430,7 +440,8 @@ void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden,
uint8_t flags = ext->ctrl_bits[btn_id]; uint8_t flags = ext->ctrl_bits[btn_id];
flags = hidden ? flags | LV_BTNM_BTN_HIDDEN : flags & (~LV_BTNM_BTN_HIDDEN); flags = hidden ? flags | LV_BTNM_BTN_HIDDEN : flags & (~LV_BTNM_BTN_HIDDEN);
flags = disabled ? flags | LV_BTNM_BTN_INACTIVE : flags & (~LV_BTNM_BTN_INACTIVE); flags = inactive ? flags | LV_BTNM_BTN_INACTIVE : flags & (~LV_BTNM_BTN_INACTIVE);
flags = no_repeat ? flags | LV_BTNM_BTN_NO_REPEAT : flags & (~LV_BTNM_BTN_NO_REPEAT);
flags = toggle ? flags | LV_BTNM_BTN_TOGGLE : flags & (~LV_BTNM_BTN_TOGGLE); flags = toggle ? flags | LV_BTNM_BTN_TOGGLE : flags & (~LV_BTNM_BTN_TOGGLE);
flags = toggle_state ? flags | LV_BTNM_BTN_TOGGLE_STATE : flags & (~LV_BTNM_BTN_TOGGLE_STATE); flags = toggle_state ? flags | LV_BTNM_BTN_TOGGLE_STATE : flags & (~LV_BTNM_BTN_TOGGLE_STATE);
@@ -459,6 +470,22 @@ void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width
lv_btnm_set_map(btnm, ext->map_p); lv_btnm_set_map(btnm, ext->map_p);
} }
/**
* Set the toggle state of all buttons
* @param btnm pointer to a button matrix object
* @param state true: toggled; false: not toggled
*/
void lv_btnm_set_btn_toggle_state_all(lv_obj_t * btnm, bool state)
{
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
uint16_t i;
for(i = 0; i < ext->btn_cnt; i++) {
if(state) ext->ctrl_bits[i] |= LV_BTNM_BTN_TOGGLE_STATE;
else ext->ctrl_bits[i] &= (~LV_BTNM_BTN_TOGGLE_STATE);
}
lv_obj_invalidate(btnm);
}
/*===================== /*=====================
* Getter functions * Getter functions
@@ -491,19 +518,36 @@ bool lv_btnm_get_recolor(const lv_obj_t * btnm)
* Get the index of the lastly "activated" button by the user (pressed, released etc) * Get the index of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb` to get the text of the button, check if hidden etc. * Useful in the the `event_cb` to get the text of the button, check if hidden etc.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return index of the last released button (LV_BTNM_PR_NONE: if unset) * @return index of the last released button (LV_BTNM_BTN_NONE: if unset)
*/ */
uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm) uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
return ext->btn_id_pr; return ext->btn_id_act;
} }
/**
* Get the text of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb`
* @param btnm pointer to button matrix object
* @return text of the last released button (NULL: if unset)
*/
const char * lv_btnm_get_active_btn_text(const lv_obj_t * btnm)
{
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if(ext->btn_id_act != LV_BTNM_BTN_NONE) {
return lv_btnm_get_btn_text(btnm, ext->btn_id_act);
} else {
return NULL;
}
}
/** /**
* Get the pressed button's index. * Get the pressed button's index.
* The button be really pressed by the user or manually set to pressed with `lv_btnm_set_pressed` * The button be really pressed by the user or manually set to pressed with `lv_btnm_set_pressed`
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return index of the pressed button (LV_BTNM_PR_NONE: if unset) * @return index of the pressed button (LV_BTNM_BTN_NONE: if unset)
*/ */
uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm) uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm)
{ {
@@ -517,10 +561,10 @@ uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm)
* @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return text of btn_index` button * @return text of btn_index` button
*/ */
uint16_t lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id) const char * lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
if(btn_id > ext->btn_cnt) return LV_BTNM_PR_NONE; if(btn_id > ext->btn_cnt) return NULL;
uint16_t txt_i = 0; uint16_t txt_i = 0;
uint16_t btn_i = 0; uint16_t btn_i = 0;
@@ -533,9 +577,9 @@ uint16_t lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
if(strcmp(ext->map_p[txt_i], "\n") == 0) txt_i ++; if(strcmp(ext->map_p[txt_i], "\n") == 0) txt_i ++;
} }
if(btn_i == ext->btn_cnt) return LV_BTNM_PR_NONE; if(btn_i == ext->btn_cnt) return NULL;
return txt_i; return ext->map_p[txt_i];
} }
/** /**
@@ -545,7 +589,7 @@ uint16_t lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id)
* @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: long press repeat is disabled; false: long press repeat enabled * @return true: long press repeat is disabled; false: long press repeat enabled
*/ */
bool lv_btnm_is_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id) bool lv_btnm_get_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
return button_is_repeat_disabled(ext->ctrl_bits[btn_id]); return button_is_repeat_disabled(ext->ctrl_bits[btn_id]);
@@ -558,7 +602,7 @@ bool lv_btnm_is_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id)
* @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: hidden; false: not hidden * @return true: hidden; false: not hidden
*/ */
bool lv_btnm_is_btn_hidden(lv_obj_t * btnm, uint16_t btn_id) bool lv_btnm_get_btn_hidden(lv_obj_t * btnm, uint16_t btn_id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
return button_is_hidden(ext->ctrl_bits[btn_id]); return button_is_hidden(ext->ctrl_bits[btn_id]);
@@ -571,7 +615,7 @@ bool lv_btnm_is_btn_hidden(lv_obj_t * btnm, uint16_t btn_id)
* @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: inactive; false: not inactive * @return true: inactive; false: not inactive
*/ */
bool lv_btnm_is_btn_inactive(lv_obj_t * btnm, uint16_t btn_id) bool lv_btnm_get_btn_inactive(lv_obj_t * btnm, uint16_t btn_id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
return button_is_inactive(ext->ctrl_bits[btn_id]); return button_is_inactive(ext->ctrl_bits[btn_id]);
@@ -581,7 +625,7 @@ bool lv_btnm_is_btn_inactive(lv_obj_t * btnm, uint16_t btn_id)
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return btn_id index a of a button not counting "\n". (The return value of lv_btnm_get_pressed/released) * @return btn_id index a of a button not counting "\n". (The return value of lv_btnm_get_pressed/released)
*/ */
bool lv_btnm_is_btn_toggle(const lv_obj_t * btnm, int16_t btn_id) bool lv_btnm_get_btn_toggle(const lv_obj_t * btnm, int16_t btn_id)
{ {
lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm); lv_btnm_ext_t * ext = lv_obj_get_ext_attr(btnm);
@@ -781,8 +825,11 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
lv_indev_get_point(param, &p); lv_indev_get_point(param, &p);
btn_pr = get_button_from_point(btnm, &p); btn_pr = get_button_from_point(btnm, &p);
invalidate_button_area(btnm, ext->btn_id_pr) /*Invalidate the old area*/;
ext->btn_id_pr = btn_pr; ext->btn_id_pr = btn_pr;
ext->btn_id_act = btn_pr; ext->btn_id_act = btn_pr;
invalidate_button_area(btnm, ext->btn_id_pr); /*Invalidate the new area*/
} }
else if(sign == LV_SIGNAL_PRESSING) { else if(sign == LV_SIGNAL_PRESSING) {
uint16_t btn_pr; uint16_t btn_pr;
@@ -792,10 +839,10 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
/*Invalidate to old and the new areas*/; /*Invalidate to old and the new areas*/;
if(btn_pr != ext->btn_id_pr) { if(btn_pr != ext->btn_id_pr) {
lv_indev_reset_lpr(param); lv_indev_reset_lpr(param);
if(ext->btn_id_pr != LV_BTNM_PR_NONE) { if(ext->btn_id_pr != LV_BTNM_BTN_NONE) {
invalidate_button_area(btnm, ext->btn_id_pr); invalidate_button_area(btnm, ext->btn_id_pr);
} }
if(btn_pr != LV_BTNM_PR_NONE) { if(btn_pr != LV_BTNM_BTN_NONE) {
invalidate_button_area(btnm, btn_pr); invalidate_button_area(btnm, btn_pr);
} }
} }
@@ -803,12 +850,11 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
ext->btn_id_pr = btn_pr; ext->btn_id_pr = btn_pr;
} }
else if(sign == LV_SIGNAL_RELEASED) { else if(sign == LV_SIGNAL_RELEASED) {
if(ext->btn_id_pr != LV_BTNM_PR_NONE) { if(ext->btn_id_pr != LV_BTNM_BTN_NONE) {
/*Toggle the button if enabled*/ /*Toggle the button if enabled*/
if(button_is_toggle(ext->ctrl_bits[ext->btn_id_pr])) { if(button_is_toggle(ext->ctrl_bits[ext->btn_id_pr])) {
if(ext->ctrl_bits[ext->btn_id_pr] & LV_BTNM_BTN_TOGGLE_STATE) { if(ext->ctrl_bits[ext->btn_id_pr] & LV_BTNM_BTN_TOGGLE_STATE) {
ext->ctrl_bits[ext->btn_id_pr] &= LV_BTNM_BTN_TOGGLE_STATE; ext->ctrl_bits[ext->btn_id_pr] &= (~LV_BTNM_BTN_TOGGLE_STATE);
} else { } else {
ext->ctrl_bits[ext->btn_id_pr] |= LV_BTNM_BTN_TOGGLE_STATE; ext->ctrl_bits[ext->btn_id_pr] |= LV_BTNM_BTN_TOGGLE_STATE;
} }
@@ -818,10 +864,10 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
/*Leave the clicked button when releases if this not the focused object in a group*/ /*Leave the clicked button when releases if this not the focused object in a group*/
lv_group_t * g = lv_obj_get_group(btnm); lv_group_t * g = lv_obj_get_group(btnm);
if(lv_group_get_focused(g) != btnm) { if(lv_group_get_focused(g) != btnm) {
ext->btn_id_pr = LV_BTNM_PR_NONE; ext->btn_id_pr = LV_BTNM_BTN_NONE;
} }
#else #else
ext->btn_id_pr = LV_BTNM_PR_NONE; ext->btn_id_pr = LV_BTNM_BTN_NONE;
#endif #endif
} }
@@ -830,7 +876,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
} }
else if(sign == LV_SIGNAL_PRESS_LOST || sign == LV_SIGNAL_DEFOCUS) { else if(sign == LV_SIGNAL_PRESS_LOST || sign == LV_SIGNAL_DEFOCUS) {
ext->btn_id_pr = LV_BTNM_PR_NONE; ext->btn_id_pr = LV_BTNM_BTN_NONE;
lv_obj_invalidate(btnm); lv_obj_invalidate(btnm);
} }
else if(sign == LV_SIGNAL_FOCUS) { else if(sign == LV_SIGNAL_FOCUS) {
@@ -846,7 +892,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
} else if(indev_type == LV_INDEV_TYPE_ENCODER) { } else if(indev_type == LV_INDEV_TYPE_ENCODER) {
/*In navigation mode don't select any button but in edit mode select the fist*/ /*In navigation mode don't select any button but in edit mode select the fist*/
if(lv_group_get_editing(lv_obj_get_group(btnm))) ext->btn_id_pr = 0; if(lv_group_get_editing(lv_obj_get_group(btnm))) ext->btn_id_pr = 0;
else ext->btn_id_pr = LV_BTNM_PR_NONE; else ext->btn_id_pr = LV_BTNM_BTN_NONE;
} else { } else {
ext->btn_id_pr = 0; ext->btn_id_pr = 0;
} }
@@ -858,18 +904,20 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
else if(sign == LV_SIGNAL_CONTROLL) { else if(sign == LV_SIGNAL_CONTROLL) {
char c = *((char *)param); char c = *((char *)param);
if(c == LV_GROUP_KEY_RIGHT) { if(c == LV_GROUP_KEY_RIGHT) {
if(ext->btn_id_pr == LV_BTNM_PR_NONE) ext->btn_id_pr = 0; if(ext->btn_id_pr == LV_BTNM_BTN_NONE) ext->btn_id_pr = 0;
else ext->btn_id_pr++; else ext->btn_id_pr++;
if(ext->btn_id_pr >= ext->btn_cnt - 1) ext->btn_id_pr = ext->btn_cnt - 1; if(ext->btn_id_pr >= ext->btn_cnt - 1) ext->btn_id_pr = ext->btn_cnt - 1;
lv_obj_invalidate(btnm); lv_obj_invalidate(btnm);
} else if(c == LV_GROUP_KEY_LEFT) { }
if(ext->btn_id_pr == LV_BTNM_PR_NONE) ext->btn_id_pr = 0; else if(c == LV_GROUP_KEY_LEFT) {
if(ext->btn_id_pr == LV_BTNM_BTN_NONE) ext->btn_id_pr = 0;
if(ext->btn_id_pr > 0) ext->btn_id_pr--; if(ext->btn_id_pr > 0) ext->btn_id_pr--;
lv_obj_invalidate(btnm); lv_obj_invalidate(btnm);
} else if(c == LV_GROUP_KEY_DOWN) { }
else if(c == LV_GROUP_KEY_DOWN) {
lv_style_t * style = lv_btnm_get_style(btnm, LV_BTNM_STYLE_BG); lv_style_t * style = lv_btnm_get_style(btnm, LV_BTNM_STYLE_BG);
/*Find the area below the the current*/ /*Find the area below the the current*/
if(ext->btn_id_pr == LV_BTNM_PR_NONE) { if(ext->btn_id_pr == LV_BTNM_BTN_NONE) {
ext->btn_id_pr = 0; ext->btn_id_pr = 0;
} else { } else {
uint16_t area_below; uint16_t area_below;
@@ -886,10 +934,11 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
if(area_below < ext->btn_cnt) ext->btn_id_pr = area_below; if(area_below < ext->btn_cnt) ext->btn_id_pr = area_below;
} }
lv_obj_invalidate(btnm); lv_obj_invalidate(btnm);
} else if(c == LV_GROUP_KEY_UP) { }
else if(c == LV_GROUP_KEY_UP) {
lv_style_t * style = lv_btnm_get_style(btnm, LV_BTNM_STYLE_BG); lv_style_t * style = lv_btnm_get_style(btnm, LV_BTNM_STYLE_BG);
/*Find the area below the the current*/ /*Find the area below the the current*/
if(ext->btn_id_pr == LV_BTNM_PR_NONE) { if(ext->btn_id_pr == LV_BTNM_BTN_NONE) {
ext->btn_id_pr = 0; ext->btn_id_pr = 0;
} else { } else {
int16_t area_above; int16_t area_above;
@@ -907,6 +956,9 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
} }
lv_obj_invalidate(btnm); lv_obj_invalidate(btnm);
} }
else if(c == LV_GROUP_KEY_ENTER) {
}
} }
else if(sign == LV_SIGNAL_GET_EDITABLE) { else if(sign == LV_SIGNAL_GET_EDITABLE) {
bool * editable = (bool *)param; bool * editable = (bool *)param;
@@ -959,6 +1011,8 @@ static void allocate_btn_areas_and_controls(const lv_obj_t * btnm, const char **
lv_mem_assert(ext->ctrl_bits); lv_mem_assert(ext->ctrl_bits);
if(ext->button_areas == NULL || ext->ctrl_bits == NULL) btn_cnt = 0; if(ext->button_areas == NULL || ext->ctrl_bits == NULL) btn_cnt = 0;
memset(ext->ctrl_bits, 0, sizeof(lv_btnm_ctrl_t) * btn_cnt);
ext->btn_cnt = btn_cnt; ext->btn_cnt = btn_cnt;
} }
@@ -969,7 +1023,8 @@ static void allocate_btn_areas_and_controls(const lv_obj_t * btnm, const char **
*/ */
static uint8_t get_button_width(lv_btnm_ctrl_t ctrl_bits) static uint8_t get_button_width(lv_btnm_ctrl_t ctrl_bits)
{ {
return ctrl_bits ? ctrl_bits & LV_BTNM_WIDTH_MASK : 1; uint8_t w = ctrl_bits & LV_BTNM_WIDTH_MASK;
return w != 0 ? w: 1;
} }
static bool button_is_hidden(lv_btnm_ctrl_t ctrl_bits) static bool button_is_hidden(lv_btnm_ctrl_t ctrl_bits)
@@ -1001,7 +1056,7 @@ static bool button_get_toggle_state(lv_btnm_ctrl_t ctrl_bits)
* Gives the button id of a button under a given point * Gives the button id of a button under a given point
* @param btnm pointer to a button matrix object * @param btnm pointer to a button matrix object
* @param p a point with absolute coordinates * @param p a point with absolute coordinates
* @return the id of the button or LV_BTNM_PR_NONE. * @return the id of the button or LV_BTNM_BTN_NONE.
*/ */
static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p) static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
{ {
@@ -1022,7 +1077,7 @@ static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
} }
} }
if(i == ext->btn_cnt) i = LV_BTNM_PR_NONE; if(i == ext->btn_cnt) i = LV_BTNM_BTN_NONE;
return i; return i;
} }

64
lv_objx/lv_btnm.h
View File

@@ -38,7 +38,7 @@ extern "C" {
#define LV_BTNM_BTN_TOGGLE 0x40 #define LV_BTNM_BTN_TOGGLE 0x40
#define LV_BTNM_BTN_TOGGLE_STATE 0x80 #define LV_BTNM_BTN_TOGGLE_STATE 0x80
#define LV_BTNM_PR_NONE 0xFFFF #define LV_BTNM_BTN_NONE 0xFFFF
/********************** /**********************
* TYPEDEFS * TYPEDEFS
**********************/ **********************/
@@ -56,8 +56,8 @@ typedef struct
lv_btnm_ctrl_t *ctrl_bits; /*Array of control bytes*/ lv_btnm_ctrl_t *ctrl_bits; /*Array of control bytes*/
lv_style_t *styles_btn[LV_BTN_STATE_NUM]; /*Styles of buttons in each state*/ lv_style_t *styles_btn[LV_BTN_STATE_NUM]; /*Styles of buttons in each state*/
uint16_t btn_cnt; /*Number of button in 'map_p'(Handled by the library)*/ uint16_t btn_cnt; /*Number of button in 'map_p'(Handled by the library)*/
uint16_t btn_id_pr; /*Index of the currently pressed button or LV_BTNM_PR_NONE*/ uint16_t btn_id_pr; /*Index of the currently pressed button or LV_BTNM_BTN_NONE*/
uint16_t btn_id_act; /*Index of the active button (being pressed/released etc) or LV_BTNM_PR_NONE */ uint16_t btn_id_act; /*Index of the active button (being pressed/released etc) or LV_BTNM_BTN_NONE */
uint8_t recolor :1; /*Enable button recoloring*/ uint8_t recolor :1; /*Enable button recoloring*/
} lv_btnm_ext_t; } lv_btnm_ext_t;
@@ -118,7 +118,7 @@ void lv_btnm_set_ctrl_map(const lv_obj_t * btnm, const lv_btnm_ctrl_t * ctrl_map
* Set the pressed button i.e. visually highlight it. * Set the pressed button i.e. visually highlight it.
* Mainly used a when the btnm is in a group to show the selected button * Mainly used a when the btnm is in a group to show the selected button
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param id index of the currently pressed button (`LV_BTNM_PR_NONE` to unpress) * @param id index of the currently pressed button (`LV_BTNM_BTN_NONE` to unpress)
*/ */
void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id); void lv_btnm_set_pressed(const lv_obj_t * btnm, uint16_t id);
@@ -149,35 +149,45 @@ void lv_btnm_set_btn_hidden(const lv_obj_t * btnm, uint16_t btn_idx, bool hidden
* Enable/disable a single button in the matrix * Enable/disable a single button in the matrix
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param disabled true: disable the button * @param ina true: make the button inactive
*/ */
void lv_btnm_set_btn_inactive(const lv_obj_t * btnm, uint16_t btn_id, bool disabled); void lv_btnm_set_btn_inactive(const lv_obj_t * btnm, uint16_t btn_id, bool ina);
/** /**
* Enable/disable long press for a single button in the matrix * Enable/disable long press for a single button in the matrix
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param disabled true: disable repeat * @param no_rep true: disable repeat
*/ */
void lv_btnm_set_btn_no_repeat(const lv_obj_t * btnm, uint16_t btn_id, bool disabled); void lv_btnm_set_btn_no_repeat(const lv_obj_t * btnm, uint16_t btn_id, bool no_rep);
/**
* Enable/disable toggling a single button in the matrix
* @param btnm pointer to button matrix object
* @param btn_id 0 based index of the button to modify.
* @param tgl true: toggle enable
*/
void lv_btnm_set_btn_toggle(const lv_obj_t * btnm, uint16_t btn_id, bool tgl);
/** /**
* Make the a single button button toggled or not toggled. * Make the a single button button toggled or not toggled.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_id index of button (not counting "\n") * @param btn_id index of button (not counting "\n")
* @param en true: enable toggling; false: disable toggling * @param state true: toggled; false: not toggled
*/ */
void lv_btnm_set_btn_toggle_state(lv_obj_t * btnm, uint16_t btn_id, bool toggle); void lv_btnm_set_btn_toggle_state(lv_obj_t * btnm, uint16_t btn_id, bool toggle);
/** /**
* Set hidden/disabled/repeat flags for a single button. * Set hidden/disabled/repeat flags for a single button.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @param btn_idx 0 based index of the button to modify. * @param btn_id 0 based index of the button to modify.
* @param hidden true: hide the button * @param hidden true: hide the button
* @param disabled true: disable the button * @param inactive true: disable the button
* @param disable_repeat true: disable repeat * @param no_repeat true: disable repeat
* @param toggle true: enable toggling
* @param toggled_state true: set toggled state
*/ */
void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden, bool disabled, bool disable_repeat, bool toggle, bool toggle_state); void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden, bool inactive, bool no_repeat, bool toggle, bool toggle_state);
/** /**
* Set a single buttons relative width. * Set a single buttons relative width.
@@ -190,6 +200,12 @@ void lv_btnm_set_btn_flags(const lv_obj_t * btnm, uint16_t btn_id, bool hidden,
*/ */
void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width); void lv_btnm_set_btn_width(const lv_obj_t * btnm, uint16_t btn_id, uint8_t width);
/**
* Set the toggle state of all buttons
* @param btnm pointer to a button matrix object
* @param state true: toggled; false: not toggled
*/
void lv_btnm_set_btn_toggle_state_all(lv_obj_t * btnm, bool state);
/*===================== /*=====================
* Getter functions * Getter functions
@@ -213,15 +229,23 @@ bool lv_btnm_get_recolor(const lv_obj_t * btnm);
* Get the index of the lastly "activated" button by the user (pressed, released etc) * Get the index of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb` to get the text of the button, check if hidden etc. * Useful in the the `event_cb` to get the text of the button, check if hidden etc.
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return index of the last released button (LV_BTNM_PR_NONE: if unset) * @return index of the last released button (LV_BTNM_BTN_NONE: if unset)
*/ */
uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm); uint16_t lv_btnm_get_active_btn(const lv_obj_t * btnm);
/**
* Get the text of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb`
* @param btnm pointer to button matrix object
* @return text of the last released button (NULL: if unset)
*/
const char * lv_btnm_get_active_btn_text(const lv_obj_t * btnm);
/** /**
* Get the pressed button's index. * Get the pressed button's index.
* The button be really pressed by the user or manually set to pressed with `lv_btnm_set_pressed` * The button be really pressed by the user or manually set to pressed with `lv_btnm_set_pressed`
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return index of the pressed button (LV_BTNM_PR_NONE: if unset) * @return index of the pressed button (LV_BTNM_BTN_NONE: if unset)
*/ */
uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm); uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm);
@@ -231,7 +255,7 @@ uint16_t lv_btnm_get_pressed_btn(const lv_obj_t * btnm);
* @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return text of btn_index` button * @return text of btn_index` button
*/ */
uint16_t lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id); const char * lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id);
/** /**
* Check whether "no repeat" for a button is set or not. * Check whether "no repeat" for a button is set or not.
@@ -240,7 +264,7 @@ uint16_t lv_btnm_get_btn_text(const lv_obj_t * btnm, uint16_t btn_id);
* @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_index the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: long press repeat is disabled; false: long press repeat enabled * @return true: long press repeat is disabled; false: long press repeat enabled
*/ */
bool lv_btnm_is_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id); bool lv_btnm_get_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id);
/** /**
* Check whether a button for a button is hidden or not. * Check whether a button for a button is hidden or not.
@@ -249,7 +273,7 @@ bool lv_btnm_is_btn_no_repeate(lv_obj_t * btnm, uint16_t btn_id);
* @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: hidden; false: not hidden * @return true: hidden; false: not hidden
*/ */
bool lv_btnm_is_btn_hidden(lv_obj_t * btnm, uint16_t btn_id); bool lv_btnm_get_btn_hidden(lv_obj_t * btnm, uint16_t btn_id);
/** /**
* Check whether a button for a button is inactive or not. * Check whether a button for a button is inactive or not.
@@ -258,14 +282,14 @@ bool lv_btnm_is_btn_hidden(lv_obj_t * btnm, uint16_t btn_id);
* @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released) * @param btn_id the index a button not counting new line characters. (The return value of lv_btnm_get_pressed/released)
* @return true: inactive; false: not inactive * @return true: inactive; false: not inactive
*/ */
bool lv_btnm_is_btn_inactive(lv_obj_t * btnm, uint16_t btn_id); bool lv_btnm_get_btn_inactive(lv_obj_t * btnm, uint16_t btn_id);
/** /**
* Check if the button can be toggled or not * Check if the button can be toggled or not
* @param btnm pointer to button matrix object * @param btnm pointer to button matrix object
* @return btn_id index a of a button not counting "\n". (The return value of lv_btnm_get_pressed/released) * @return btn_id index a of a button not counting "\n". (The return value of lv_btnm_get_pressed/released)
*/ */
bool lv_btnm_is_btn_toggle(const lv_obj_t * btnm, int16_t btn_id); bool lv_btnm_get_btn_toggle(const lv_obj_t * btnm, int16_t btn_id);
/** /**
* Check if the button is toggled or not * Check if the button is toggled or not

77
lv_objx/lv_kb.c
View File

@@ -25,7 +25,7 @@
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
static lv_res_t lv_kb_signal(lv_obj_t * kb, lv_signal_t sign, void * param); static lv_res_t lv_kb_signal(lv_obj_t * kb, lv_signal_t sign, void * param);
static lv_res_t lv_kb_def_action(lv_obj_t * kb, const char * txt); static void lv_kb_def_event_cb(lv_obj_t * kb);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
@@ -33,10 +33,10 @@ static lv_res_t lv_kb_def_action(lv_obj_t * kb, const char * txt);
static lv_signal_cb_t ancestor_signal; static lv_signal_cb_t ancestor_signal;
static const char * kb_map_lc[] = { static const char * kb_map_lc[] = {
"\2051#", "\204q", "\204w", "\204e", "\204r", "\204t", "\204y", "\204u", "\204i", "\204o", "\204p", "\207Bksp", "\n", "#", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p", "Bksp", "\n",
"\226ABC", "\203a", "\203s", "\203d", "\203f", "\203g", "\203h", "\203j", "\203k", "\203l", "\207Enter", "\n", "ABC", "a", "s", "d", "f", "g", "h", "j", "k", "l", "Enter", "\n",
"_", "-", "z", "x", "c", "v", "b", "n", "m", ".", ",", ":", "\n", "_", "-", "z", "x", "c", "v", "b", "n", "m", ".", ",", ":", "\n",
"\202"LV_SYMBOL_CLOSE, "\202"LV_SYMBOL_LEFT, "\206 ", "\202"LV_SYMBOL_RIGHT, "\202"LV_SYMBOL_OK, "" LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
}; };
static const lv_btnm_ctrl_t kb_ctrl_lc_map[] = { static const lv_btnm_ctrl_t kb_ctrl_lc_map[] = {
@@ -47,10 +47,10 @@ static const lv_btnm_ctrl_t kb_ctrl_lc_map[] = {
}; };
static const char * kb_map_uc[] = { static const char * kb_map_uc[] = {
"\2051#", "\204Q", "\204W", "\204E", "\204R", "\204T", "\204Y", "\204U", "\204I", "\204O", "\204P", "\207Bksp", "\n", "#", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", "Bksp", "\n",
"\226abc", "\203A", "\203S", "\203D", "\203F", "\203G", "\203H", "\203J", "\203K", "\203L", "\207Enter", "\n", "abc", "A", "S", "D", "F", "G", "H", "J", "K", "L", "Enter", "\n",
"_", "-", "Z", "X", "C", "V", "B", "N", "M", ".", ",", ":", "\n", "_", "-", "Z", "X", "C", "V", "B", "N", "M", ".", ",", ":", "\n",
"\202"LV_SYMBOL_CLOSE, "\202"LV_SYMBOL_LEFT, "\206 ", "\202"LV_SYMBOL_RIGHT, "\202"LV_SYMBOL_OK, "" LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
}; };
static const lv_btnm_ctrl_t kb_ctrl_uc_map[] = { static const lv_btnm_ctrl_t kb_ctrl_uc_map[] = {
@@ -61,10 +61,10 @@ static const lv_btnm_ctrl_t kb_ctrl_uc_map[] = {
}; };
static const char * kb_map_spec[] = { static const char * kb_map_spec[] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "\202Bksp", "\n", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "Bksp", "\n",
"\222abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n", "abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
"\\", "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n", "\\", "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
"\202"LV_SYMBOL_CLOSE, "\202"LV_SYMBOL_LEFT, "\206 ", "\202"LV_SYMBOL_RIGHT, "\202"LV_SYMBOL_OK, "" LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
}; };
static const lv_btnm_ctrl_t kb_ctrl_spec_map[] = { static const lv_btnm_ctrl_t kb_ctrl_spec_map[] = {
@@ -130,7 +130,6 @@ lv_obj_t * lv_kb_create(lv_obj_t * par, const lv_obj_t * copy)
if(copy == NULL) { if(copy == NULL) {
lv_obj_set_size(new_kb, LV_DPI * 3, LV_DPI * 2); lv_obj_set_size(new_kb, LV_DPI * 3, LV_DPI * 2);
lv_obj_align(new_kb, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0); lv_obj_align(new_kb, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
lv_btnm_set_action(new_kb, lv_kb_def_action);
lv_btnm_set_map(new_kb, kb_map_lc); lv_btnm_set_map(new_kb, kb_map_lc);
lv_btnm_set_ctrl_map(new_kb, kb_ctrl_lc_map); lv_btnm_set_ctrl_map(new_kb, kb_ctrl_lc_map);
@@ -367,7 +366,15 @@ static lv_res_t lv_kb_signal(lv_obj_t * kb, lv_signal_t sign, void * param)
if(sign == LV_SIGNAL_CLEANUP) { if(sign == LV_SIGNAL_CLEANUP) {
/*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/ /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
} else if(sign == LV_SIGNAL_GET_TYPE) { }
else if(sign == LV_SIGNAL_RELEASED) {
lv_kb_def_event_cb(kb);
}
else if(sign == LV_SIGNAL_LONG_PRESS_REP) {
bool no_rep = lv_btnm_get_btn_no_repeate(kb, lv_btnm_get_active_btn(kb));
if(no_rep == false) lv_kb_def_event_cb(kb);
}
else if(sign == LV_SIGNAL_GET_TYPE) {
lv_obj_type_t * buf = param; lv_obj_type_t * buf = param;
uint8_t i; uint8_t i;
for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/ for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/
@@ -380,55 +387,52 @@ static lv_res_t lv_kb_signal(lv_obj_t * kb, lv_signal_t sign, void * param)
} }
/** /**
* Called when a button of 'kb_btnm' is released * Called when a button of the keyboard is released
* @param btnm pointer to 'kb_btnm' * @param kb pointer to a keyboard
* @param i the index of the released button from the current btnm map * @param event type of the event
* @return LV_ACTION_RES_INV if the btnm is deleted else LV_ACTION_RES_OK
*/ */
static lv_res_t lv_kb_def_action(lv_obj_t * kb, const char * txt) static void lv_kb_def_event_cb(lv_obj_t * kb)
{ {
lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb); lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
lv_res_t res = LV_RES_OK;
uint16_t btn_id = lv_btnm_get_active_btn(kb);
if(btn_id == LV_BTNM_BTN_NONE) return;
if(lv_btnm_get_btn_hidden(kb, btn_id)) return;
if(lv_btnm_get_btn_inactive(kb, btn_id)) return;
const char * txt = lv_btnm_get_active_btn_text(kb);
if(txt == NULL) return;
/*Do the corresponding action according to the text of the button*/ /*Do the corresponding action according to the text of the button*/
if(strcmp(txt, "abc") == 0) { if(strcmp(txt, "abc") == 0) {
lv_btnm_set_map(kb, kb_map_lc); lv_btnm_set_map(kb, kb_map_lc);
lv_btnm_set_ctrl_map(kb, kb_ctrl_lc_map); lv_btnm_set_ctrl_map(kb, kb_ctrl_lc_map);
return LV_RES_OK; return;
} else if(strcmp(txt, "ABC") == 0) { } else if(strcmp(txt, "ABC") == 0) {
lv_btnm_set_map(kb, kb_map_uc); lv_btnm_set_map(kb, kb_map_uc);
lv_btnm_set_ctrl_map(kb, kb_ctrl_uc_map); lv_btnm_set_ctrl_map(kb, kb_ctrl_uc_map);
return LV_RES_OK; return;
} else if(strcmp(txt, "1#") == 0) { } else if(strcmp(txt, "1#") == 0) {
lv_btnm_set_map(kb, kb_map_spec); lv_btnm_set_map(kb, kb_map_spec);
lv_btnm_set_ctrl_map(kb, kb_ctrl_spec_map); lv_btnm_set_ctrl_map(kb, kb_ctrl_spec_map);
return LV_RES_OK; return;
} else if(strcmp(txt, LV_SYMBOL_CLOSE) == 0) { } else if(strcmp(txt, LV_SYMBOL_CLOSE) == 0) {
if(kb->event_cb) { if(kb->event_cb) {
res = lv_obj_send_event(kb, LV_EVENT_CANCEL); lv_obj_send_event(kb, LV_EVENT_CANCEL);
if(res != LV_RES_OK) return res;
} }
else { else {
lv_kb_set_ta(kb, NULL); /*De-assign the text area to hide it cursor if needed*/ lv_kb_set_ta(kb, NULL); /*De-assign the text area to hide it cursor if needed*/
lv_obj_del(kb); lv_obj_del(kb);
} }
return res; return;
} else if(strcmp(txt, LV_SYMBOL_OK) == 0) { } else if(strcmp(txt, LV_SYMBOL_OK) == 0) {
if(kb->event_cb) { if(kb->event_cb) lv_obj_send_event(kb, LV_EVENT_APPLY);
res = lv_obj_send_event(kb, LV_EVENT_APPLY); else lv_kb_set_ta(kb, NULL); /*De-assign the text area to hide it cursor if needed*/
if(res != LV_RES_OK) return res; return;
}
else {
lv_kb_set_ta(kb, NULL); /*De-assign the text area to hide it cursor if needed*/
res = lv_obj_del(kb);
}
return res;
} }
if(res != LV_RES_OK) return res; /*The keyboard might be deleted in the actions*/
/*Add the characters to the text area if set*/ /*Add the characters to the text area if set*/
if(ext->ta == NULL) return res; if(ext->ta == NULL) return;
if(strcmp(txt, "Enter") == 0)lv_ta_add_char(ext->ta, '\n'); if(strcmp(txt, "Enter") == 0)lv_ta_add_char(ext->ta, '\n');
else if(strcmp(txt, LV_SYMBOL_LEFT) == 0) lv_ta_cursor_left(ext->ta); else if(strcmp(txt, LV_SYMBOL_LEFT) == 0) lv_ta_cursor_left(ext->ta);
@@ -455,7 +459,6 @@ static lv_res_t lv_kb_def_action(lv_obj_t * kb, const char * txt)
} else { } else {
lv_ta_add_text(ext->ta, txt); lv_ta_add_text(ext->ta, txt);
} }
return LV_RES_OK;
} }
#endif #endif

91
lv_objx/lv_mbox.c
View File

@@ -7,6 +7,7 @@
/********************* /*********************
* INCLUDES * INCLUDES
*********************/ *********************/
#include <lvgl/lv_objx/lv_btnm.h>
#include "lv_mbox.h" #include "lv_mbox.h"
#if LV_USE_MBOX != 0 #if LV_USE_MBOX != 0
@@ -37,8 +38,8 @@
**********************/ **********************/
static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param); static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param);
static void mbox_realign(lv_obj_t * mbox); static void mbox_realign(lv_obj_t * mbox);
static lv_res_t lv_mbox_close_action(lv_obj_t * btn, const char * txt);
static void lv_mbox_close_end_cb(lv_obj_t * mbox); static void lv_mbox_close_end_cb(lv_obj_t * mbox);
static void lv_mbox_default_event_cb(lv_obj_t * mbox, lv_event_t event);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
@@ -93,6 +94,7 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, const lv_obj_t * copy)
lv_cont_set_fit2(new_mbox, LV_FIT_NONE, LV_FIT_TIGHT); lv_cont_set_fit2(new_mbox, LV_FIT_NONE, LV_FIT_TIGHT);
lv_obj_set_width(new_mbox, LV_DPI * 2); lv_obj_set_width(new_mbox, LV_DPI * 2);
lv_obj_align(new_mbox, NULL, LV_ALIGN_CENTER, 0, 0); lv_obj_align(new_mbox, NULL, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_event_cb(new_mbox, lv_mbox_default_event_cb);
/*Set the default styles*/ /*Set the default styles*/
lv_theme_t * th = lv_theme_get_current(); lv_theme_t * th = lv_theme_get_current();
@@ -131,9 +133,8 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, const lv_obj_t * copy)
* @param mbox pointer to message box object * @param mbox pointer to message box object
* @param btn_map button descriptor (button matrix map). * @param btn_map button descriptor (button matrix map).
* E.g. a const char *txt[] = {"ok", "close", ""} (Can not be local variable) * E.g. a const char *txt[] = {"ok", "close", ""} (Can not be local variable)
* @param action a function which will be called when a button is released
*/ */
void lv_mbox_add_btns(lv_obj_t * mbox, const char ** btn_map, lv_btnm_action_t action) void lv_mbox_add_btns(lv_obj_t * mbox, const char ** btn_map)
{ {
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox); lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
@@ -153,8 +154,7 @@ void lv_mbox_add_btns(lv_obj_t * mbox, const char ** btn_map, lv_btnm_action_t a
} }
lv_btnm_set_map(ext->btnm, btn_map); lv_btnm_set_map(ext->btnm, btn_map);
if(action == NULL) lv_btnm_set_action(ext->btnm, lv_mbox_close_action); /*Set a default action anyway*/ lv_obj_set_parent_event(ext->btnm, true);
else lv_btnm_set_action(ext->btnm, action);
mbox_realign(mbox); mbox_realign(mbox);
} }
@@ -176,19 +176,6 @@ void lv_mbox_set_text(lv_obj_t * mbox, const char * txt)
mbox_realign(mbox); mbox_realign(mbox);
} }
/**
* Stop the action to call when button is released
* @param pointer to an 'lv_btnm_action_t' action. In the action you need to use `lv_mbox_get_from_btn()` to get the `mbox`.
* @param pointer to an 'lv_btnm_action_t' action
*/
void lv_mbox_set_action(lv_obj_t * mbox, lv_btnm_action_t action)
{
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
lv_btnm_set_action(ext->btnm, action);
}
/** /**
* Set animation duration * Set animation duration
* @param mbox pointer to a message box object * @param mbox pointer to a message box object
@@ -311,16 +298,29 @@ const char * lv_mbox_get_text(const lv_obj_t * mbox)
} }
/** /**
* Get the message box object from one of its button. * Get the index of the lastly "activated" button by the user (pressed, released etc)
* It is useful in the button release actions where only the button is known * Useful in the the `event_cb`.
* @param btn pointer to a button of a message box * @param btnm pointer to button matrix object
* @return pointer to the button's message box * @return index of the last released button (LV_BTNM_BTN_NONE: if unset)
*/ */
lv_obj_t * lv_mbox_get_from_btn(const lv_obj_t * btn) uint16_t lv_mbox_get_active_btn(lv_obj_t * mbox)
{ {
lv_obj_t * mbox = lv_obj_get_parent(btn); lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
if(ext->btnm) return lv_btnm_get_active_btn(ext->btnm);
else return LV_BTNM_BTN_NONE;
}
return mbox; /**
* Get the text of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb`.
* @param btnm pointer to button matrix object
* @return text of the last released button (NULL: if unset)
*/
const char * lv_mbox_get_active_btn_text(lv_obj_t * mbox)
{
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
if(ext->btnm) return lv_btnm_get_active_btn_text(ext->btnm);
else return NULL;
} }
/** /**
@@ -402,7 +402,6 @@ lv_obj_t * lv_mbox_get_btnm(lv_obj_t * mbox)
return ext->btnm; return ext->btnm;
} }
/********************** /**********************
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
@@ -437,10 +436,19 @@ static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
if(lv_obj_get_width(mbox) != lv_area_get_width(param)) { if(lv_obj_get_width(mbox) != lv_area_get_width(param)) {
mbox_realign(mbox); mbox_realign(mbox);
} }
} else if(sign == LV_SIGNAL_STYLE_CHG) { }
else if(sign == LV_SIGNAL_STYLE_CHG) {
mbox_realign(mbox); mbox_realign(mbox);
} else if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS || }
else if(sign == LV_SIGNAL_PRESSED) {
/*If the message box was pressed clear the last active button*/
if(ext->btnm) {
lv_btnm_ext_t * btnm_ext = lv_obj_get_ext_attr(ext->btnm);
btnm_ext->btn_id_act = LV_BTNM_BTN_NONE;
}
}
else if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS ||
sign == LV_SIGNAL_CONTROLL || sign == LV_SIGNAL_GET_EDITABLE) { sign == LV_SIGNAL_CONTROLL || sign == LV_SIGNAL_GET_EDITABLE) {
if(ext->btnm) { if(ext->btnm) {
ext->btnm->signal_cb(ext->btnm, sign, param); ext->btnm->signal_cb(ext->btnm, sign, param);
@@ -456,7 +464,7 @@ static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
/*In navigation mode don't select any button but in edit mode select the fist*/ /*In navigation mode don't select any button but in edit mode select the fist*/
lv_btnm_ext_t * btnm_ext = lv_obj_get_ext_attr(ext->btnm); lv_btnm_ext_t * btnm_ext = lv_obj_get_ext_attr(ext->btnm);
if(lv_group_get_editing(lv_obj_get_group(mbox))) btnm_ext->btn_id_pr = 0; if(lv_group_get_editing(lv_obj_get_group(mbox))) btnm_ext->btn_id_pr = 0;
else btnm_ext->btn_id_pr = LV_BTNM_PR_NONE; else btnm_ext->btn_id_pr = LV_BTNM_BTN_NONE;
} }
#endif #endif
} }
@@ -497,20 +505,21 @@ static void mbox_realign(lv_obj_t * mbox)
} }
} }
static lv_res_t lv_mbox_close_action(lv_obj_t * btn, const char * txt)
{
lv_obj_t * mbox = lv_mbox_get_from_btn(btn);
if(txt[0] != '\0') {
lv_mbox_start_auto_close(mbox, 0);
return LV_RES_INV;
}
return LV_RES_OK;
}
static void lv_mbox_close_end_cb(lv_obj_t * mbox) static void lv_mbox_close_end_cb(lv_obj_t * mbox)
{ {
lv_obj_del(mbox); lv_obj_del(mbox);
} }
static void lv_mbox_default_event_cb(lv_obj_t * mbox, lv_event_t event)
{
if(event != LV_EVENT_CLICKED) return;
uint16_t btn_id = lv_mbox_get_active_btn(mbox);
if(btn_id == LV_BTNM_BTN_NONE) return;
lv_mbox_start_auto_close(mbox, 0);
}
#endif #endif

28
lv_objx/lv_mbox.h
View File

@@ -90,9 +90,8 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, const lv_obj_t * copy);
* @param mbox pointer to message box object * @param mbox pointer to message box object
* @param btn_map button descriptor (button matrix map). * @param btn_map button descriptor (button matrix map).
* E.g. a const char *txt[] = {"ok", "close", ""} (Can not be local variable) * E.g. a const char *txt[] = {"ok", "close", ""} (Can not be local variable)
* @param action a function which will be called when a button is released
*/ */
void lv_mbox_add_btns(lv_obj_t * mbox, const char **btn_map, lv_btnm_action_t action); void lv_mbox_add_btns(lv_obj_t * mbox, const char **btn_mapaction);
/*===================== /*=====================
* Setter functions * Setter functions
@@ -105,13 +104,6 @@ void lv_mbox_add_btns(lv_obj_t * mbox, const char **btn_map, lv_btnm_action_t ac
*/ */
void lv_mbox_set_text(lv_obj_t * mbox, const char * txt); void lv_mbox_set_text(lv_obj_t * mbox, const char * txt);
/**
* Stop the action to call when button is released
* @param mbox pointer to a message box object
* @param pointer to an 'lv_btnm_action_t' action. In the action you need to use `lv_mbox_get_from_btn()` to get the `mbox`.
*/
void lv_mbox_set_action(lv_obj_t * mbox, lv_btnm_action_t action);
/** /**
* Set animation duration * Set animation duration
* @param mbox pointer to a message box object * @param mbox pointer to a message box object
@@ -159,12 +151,20 @@ void lv_mbox_set_recolor(lv_obj_t * mbox, bool en);
const char * lv_mbox_get_text(const lv_obj_t * mbox); const char * lv_mbox_get_text(const lv_obj_t * mbox);
/** /**
* Get the message box object from one of its button. * Get the index of the lastly "activated" button by the user (pressed, released etc)
* It is useful in the button release actions where only the button is known * Useful in the the `event_cb`.
* @param btn pointer to a button of a message box * @param btnm pointer to button matrix object
* @return pointer to the button's message box * @return index of the last released button (LV_BTNM_BTN_NONE: if unset)
*/ */
lv_obj_t * lv_mbox_get_from_btn(const lv_obj_t * btn); uint16_t lv_mbox_get_active_btn(lv_obj_t * mbox);
/**
* Get the text of the lastly "activated" button by the user (pressed, released etc)
* Useful in the the `event_cb`.
* @param btnm pointer to button matrix object
* @return text of the last released button (NULL: if unset)
*/
const char * lv_mbox_get_active_btn_text(lv_obj_t * mbox);
/** /**
* Get the animation duration (close animation time) * Get the animation duration (close animation time)

84
lv_objx/lv_tabview.c
View File

@@ -39,7 +39,7 @@ static lv_res_t tabpage_scrl_signal(lv_obj_t * tab_scrl, lv_signal_t sign, void
static void tabpage_pressed_handler(lv_obj_t * tabview, lv_obj_t * tabpage); static void tabpage_pressed_handler(lv_obj_t * tabview, lv_obj_t * tabpage);
static void tabpage_pressing_handler(lv_obj_t * tabview, lv_obj_t * tabpage); static void tabpage_pressing_handler(lv_obj_t * tabview, lv_obj_t * tabpage);
static void tabpage_press_lost_handler(lv_obj_t * tabview, lv_obj_t * tabpage); static void tabpage_press_lost_handler(lv_obj_t * tabview, lv_obj_t * tabpage);
static lv_res_t tab_btnm_action(lv_obj_t * tab_btnm, const char * tab_name); static void tab_btnm_event_cb(lv_obj_t * tab_btnm, lv_event_t event);
static void tabview_realign(lv_obj_t * tabview); static void tabview_realign(lv_obj_t * tabview);
/********************** /**********************
@@ -89,7 +89,6 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
ext->content = NULL; ext->content = NULL;
ext->indic = NULL; ext->indic = NULL;
ext->btns = NULL; ext->btns = NULL;
ext->tab_load_action = NULL;
ext->btns_pos = LV_TABVIEW_BTNS_POS_TOP; ext->btns_pos = LV_TABVIEW_BTNS_POS_TOP;
ext->anim_time = LV_TABVIEW_ANIM_TIME; ext->anim_time = LV_TABVIEW_ANIM_TIME;
ext->btns_hide = 0; ext->btns_hide = 0;
@@ -111,8 +110,7 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
ext->btns = lv_btnm_create(new_tabview, NULL); ext->btns = lv_btnm_create(new_tabview, NULL);
lv_obj_set_height(ext->btns, 3 * LV_DPI / 4); lv_obj_set_height(ext->btns, 3 * LV_DPI / 4);
lv_btnm_set_map(ext->btns, tab_def); lv_btnm_set_map(ext->btns, tab_def);
lv_btnm_set_action(ext->btns, tab_btnm_action); lv_obj_set_event_cb(ext->btns, tab_btnm_event_cb);
lv_btnm_set_toggle(ext->btns, true, 0);
ext->indic = lv_obj_create(ext->btns, NULL); ext->indic = lv_obj_create(ext->btns, NULL);
lv_obj_set_width(ext->indic, LV_DPI); lv_obj_set_width(ext->indic, LV_DPI);
@@ -151,7 +149,6 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
ext->indic = lv_obj_create(ext->btns, copy_ext->indic); ext->indic = lv_obj_create(ext->btns, copy_ext->indic);
ext->content = lv_cont_create(new_tabview, copy_ext->content); ext->content = lv_cont_create(new_tabview, copy_ext->content);
ext->anim_time = copy_ext->anim_time; ext->anim_time = copy_ext->anim_time;
ext->tab_load_action = copy_ext->tab_load_action;
ext->tab_name_ptr = lv_mem_alloc(sizeof(char *)); ext->tab_name_ptr = lv_mem_alloc(sizeof(char *));
lv_mem_assert(ext->tab_name_ptr); lv_mem_assert(ext->tab_name_ptr);
@@ -218,18 +215,10 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
/*Extend the button matrix map with the new name*/ /*Extend the button matrix map with the new name*/
char * name_dm; char * name_dm;
if((name[0] & LV_BTNM_CTRL_MASK) == LV_BTNM_CTRL_CODE) { /*If control byte presented let is*/ name_dm = lv_mem_alloc(strlen(name) + 1); /*+1 for the the closing '\0' */
name_dm = lv_mem_alloc(strlen(name) + 1); /*+1 for the the closing '\0' */ lv_mem_assert(name_dm);
lv_mem_assert(name_dm); if(name_dm == NULL) return NULL;
if(name_dm == NULL) return NULL; strcpy(name_dm, name);
strcpy(name_dm, name);
} else { /*Set a no long press control byte is not presented*/
name_dm = lv_mem_alloc(strlen(name) + 2); /*+1 for the the closing '\0' and +1 for the control byte */
lv_mem_assert(name_dm);
if(name_dm == NULL) return NULL;
name_dm[0] = '\221';
strcpy(&name_dm[1], name);
}
ext->tab_cnt++; ext->tab_cnt++;
ext->tab_name_ptr = lv_mem_realloc(ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt + 1)); ext->tab_name_ptr = lv_mem_realloc(ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt + 1));
@@ -240,6 +229,7 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
ext->tab_name_ptr[ext->tab_cnt] = ""; ext->tab_name_ptr[ext->tab_cnt] = "";
lv_btnm_set_map(ext->btns, ext->tab_name_ptr); lv_btnm_set_map(ext->btns, ext->tab_name_ptr);
lv_btnm_set_btn_no_repeat(ext->btns, ext->tab_cnt - 1, true);
/*Modify the indicator size*/ /*Modify the indicator size*/
lv_style_t * style_tabs = lv_obj_get_style(ext->btns); lv_style_t * style_tabs = lv_obj_get_style(ext->btns);
@@ -250,10 +240,11 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
/*Set the first btn as active*/ /*Set the first btn as active*/
if(ext->tab_cnt == 1) { if(ext->tab_cnt == 1) {
ext->tab_cur = 0; ext->tab_cur = 0;
lv_tabview_set_tab_act(tabview, 0, false);
tabview_realign(tabview); /*To set the proper btns height*/ tabview_realign(tabview); /*To set the proper btns height*/
} }
lv_tabview_set_tab_act(tabview, ext->tab_cur, false);
return h; return h;
} }
@@ -278,7 +269,8 @@ void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, bool anim_en)
lv_res_t res = LV_RES_OK; lv_res_t res = LV_RES_OK;
if(id >= ext->tab_cnt) id = ext->tab_cnt - 1; if(id >= ext->tab_cnt) id = ext->tab_cnt - 1;
if(ext->tab_load_action && id != ext->tab_cur) res = ext->tab_load_action(tabview, id);
if(id != ext->tab_cur) res = lv_obj_send_event(tabview, LV_EVENT_VALUE_CHANGED);
if(res != LV_RES_OK) return; /*Prevent the tab loading*/ if(res != LV_RES_OK) return; /*Prevent the tab loading*/
ext->tab_cur = id; ext->tab_cur = id;
@@ -331,19 +323,7 @@ void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, bool anim_en)
#endif #endif
} }
lv_btnm_set_toggle(ext->btns, true, ext->tab_cur); lv_btnm_set_btn_toggle_state(ext->btns, ext->tab_cur, true);
}
/**
* Set an action to call when a tab is loaded (Good to create content only if required)
* lv_tabview_get_act() still gives the current (old) tab (to remove content from here)
* @param tabview pointer to a tabview object
* @param action pointer to a function to call when a btn is loaded
*/
void lv_tabview_set_tab_load_action(lv_obj_t * tabview, lv_tabview_action_t action)
{
lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
ext->tab_load_action = action;
} }
/** /**
@@ -484,17 +464,6 @@ lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id)
return NULL; return NULL;
} }
/**
* Get the tab load action
* @param tabview pointer to a tabview object
* @param return the current btn load action
*/
lv_tabview_action_t lv_tabview_get_tab_load_action(const lv_obj_t * tabview)
{
lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
return ext->tab_load_action;
}
/** /**
* Get horizontal sliding is enabled or not * Get horizontal sliding is enabled or not
* @param tabview pointer to Tab view object * @param tabview pointer to Tab view object
@@ -806,26 +775,23 @@ static void tabpage_press_lost_handler(lv_obj_t * tabview, lv_obj_t * tabpage)
} }
/** /**
* Called when a tab button is released * Called when a tab button is clicked
* @param tab_btnm pointer to the tab's button matrix object * @param tab_btnm pointer to the tab's button matrix object
* @param id the id of the tab (>= 0) * @param event type of the event
* @return LV_ACTION_RES_OK because the button matrix in not deleted in the function
*/ */
static lv_res_t tab_btnm_action(lv_obj_t * tab_btnm, const char * tab_name) static void tab_btnm_event_cb(lv_obj_t * tab_btnm, lv_event_t event)
{ {
if(event != LV_EVENT_CLICKED) return;
uint16_t btn_id = lv_btnm_get_active_btn(tab_btnm);
if(btn_id == LV_BTNM_BTN_NONE) return;
lv_btnm_set_btn_toggle_state_all(tab_btnm, false);
lv_btnm_set_btn_toggle_state(tab_btnm, btn_id, true);
lv_obj_t * tab = lv_obj_get_parent(tab_btnm); lv_obj_t * tab = lv_obj_get_parent(tab_btnm);
const char ** tabs_map = lv_btnm_get_map(tab_btnm); lv_tabview_set_tab_act(tab, btn_id, true);
uint8_t i = 0;
while(tabs_map[i][0] != '\0') {
if(strcmp(&tabs_map[i][1], tab_name) == 0) break; /*[1] to skip the control byte*/
i++;
}
lv_tabview_set_tab_act(tab, i, true);
return LV_RES_OK;
} }
/** /**

21
lv_objx/lv_tabview.h
View File

@@ -42,11 +42,6 @@ extern "C" {
* TYPEDEFS * TYPEDEFS
**********************/ **********************/
/* parametes: pointer to a tabview object, tab_id
* return: LV_RES_INV: to prevent the loading of the tab; LV_RES_OK: if everything is fine*/
typedef lv_res_t (*lv_tabview_action_t)(lv_obj_t *, uint16_t);
enum { enum {
LV_TABVIEW_BTNS_POS_TOP, LV_TABVIEW_BTNS_POS_TOP,
LV_TABVIEW_BTNS_POS_BOTTOM, LV_TABVIEW_BTNS_POS_BOTTOM,
@@ -71,7 +66,6 @@ typedef struct
uint8_t drag_hor :1; uint8_t drag_hor :1;
uint8_t btns_hide :1; uint8_t btns_hide :1;
lv_tabview_btns_pos_t btns_pos :1; lv_tabview_btns_pos_t btns_pos :1;
lv_tabview_action_t tab_load_action;
} lv_tabview_ext_t; } lv_tabview_ext_t;
enum { enum {
@@ -128,14 +122,6 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name);
*/ */
void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, bool anim_en); void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, bool anim_en);
/**
* Set an action to call when a tab is loaded (Good to create content only if required)
* lv_tabview_get_act() still gives the current (old) tab (to remove content from here)
* @param tabview pointer to a tabview object
* @param action pointer to a function to call when a tab is loaded
*/
void lv_tabview_set_tab_load_action(lv_obj_t *tabview, lv_tabview_action_t action);
/** /**
* Enable horizontal sliding with touch pad * Enable horizontal sliding with touch pad
* @param tabview pointer to Tab view object * @param tabview pointer to Tab view object
@@ -197,13 +183,6 @@ uint16_t lv_tabview_get_tab_count(const lv_obj_t * tabview);
*/ */
lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id); lv_obj_t * lv_tabview_get_tab(const lv_obj_t * tabview, uint16_t id);
/**
* Get the tab load action
* @param tabview pointer to a tabview object
* @param return the current tab load action
*/
lv_tabview_action_t lv_tabview_get_tab_load_action(const lv_obj_t *tabview);
/** /**
* Get horizontal sliding is enabled or not * Get horizontal sliding is enabled or not
* @param tabview pointer to Tab view object * @param tabview pointer to Tab view object

2
lv_objx/lv_tileview.c
View File

@@ -134,7 +134,7 @@ void lv_tileview_add_element(lv_obj_t * element)
{ {
/* Let objects eventto propaget to the scrollable part of the tileview. /* Let objects eventto propaget to the scrollable part of the tileview.
* It is required the handle dargging of the tileview with the element.*/ * It is required the handle dargging of the tileview with the element.*/
element->event_parent = 1; element->parent_event = 1;
lv_obj_set_drag_parent(element, true); lv_obj_set_drag_parent(element, true);
} }