diff --git a/lv_conf_templ.h b/lv_conf_templ.h index 0a40b3807..1622b01e8 100644 --- a/lv_conf_templ.h +++ b/lv_conf_templ.h @@ -227,6 +227,12 @@ #define LV_TABVIEW_ANIM_TIME 300 /*Time of slide animation [ms] (0: no animation)*/ #endif +/*Tileview (dependencies: lv_page) */ +#define USE_LV_TILEVIEW 1 +#if USE_LV_TILEVIEW +#define LV_TILEVIEW_ANIM_TIME 300 /*Time of slide animation [ms] (0: no animation)*/ +#endif + /************************* * Data visualizer objects *************************/ diff --git a/lv_core/lv_indev.c b/lv_core/lv_indev.c index 8119b12bc..b0ccd1d15 100644 --- a/lv_core/lv_indev.c +++ b/lv_core/lv_indev.c @@ -821,11 +821,12 @@ static void indev_drag(lv_indev_proc_t * state) if(lv_obj_get_drag(drag_obj) == false) return; - /*If still there is no drag then count the movement*/ - if(state->drag_range_out == 0) { - state->drag_sum.x += state->vect.x; - state->drag_sum.y += state->vect.y; + /*Count the movement by drag*/ + state->drag_sum.x += state->vect.x; + state->drag_sum.y += state->vect.y; + /*Enough move?*/ + if(state->drag_range_out == 0) { /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/ if(LV_MATH_ABS(state->drag_sum.x) >= LV_INDEV_DRAG_LIMIT || LV_MATH_ABS(state->drag_sum.y) >= LV_INDEV_DRAG_LIMIT) { diff --git a/lv_objx/lv_list.c b/lv_objx/lv_list.c index b0f485ec4..6e7a232fd 100644 --- a/lv_objx/lv_list.c +++ b/lv_objx/lv_list.c @@ -326,6 +326,9 @@ void lv_list_set_style(lv_obj_t * list, lv_list_style_t type, lv_style_t * style case LV_LIST_STYLE_SB: lv_page_set_style(list, LV_PAGE_STYLE_SB, style); break; + case LV_LIST_STYLE_EDGE_FLASH: + lv_page_set_style(list, LV_PAGE_STYLE_EDGE_FLASH, style); + break; case LV_LIST_STYLE_BTN_REL: ext->styles_btn[LV_BTN_STATE_REL] = style; btn_style_refr = LV_BTN_STYLE_REL; @@ -545,6 +548,9 @@ lv_style_t * lv_list_get_style(const lv_obj_t * list, lv_list_style_t type) case LV_LIST_STYLE_SB: style = lv_page_get_style(list, LV_PAGE_STYLE_SCRL); break; + case LV_LIST_STYLE_EDGE_FLASH: + style = lv_page_get_style(list, LV_PAGE_STYLE_EDGE_FLASH); + break; case LV_LIST_STYLE_BTN_REL: style = ext->styles_btn[LV_BTN_STATE_REL]; break; @@ -827,9 +833,12 @@ static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * para res = ancestor_btn_signal(btn, sign, param); if(res != LV_RES_OK) return res; -#if USE_LV_GROUP if(sign == LV_SIGNAL_RELEASED) { lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn)); + lv_list_ext_t * ext = lv_obj_get_ext_attr(list); + ext->page.scroll_prop_ip = 0; + +#if USE_LV_GROUP lv_group_t * g = lv_obj_get_group(list); if(lv_group_get_focused(g) == list && lv_indev_is_dragging(lv_indev_get_act()) == false) { /* Is the list is focused then be sure only the button being released @@ -849,16 +858,23 @@ static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * para /* If `click_focus == 1` then LV_SIGNAL_FOCUS need to know which button triggered the focus * to mark it as selected (pressed state)*/ last_clicked_btn = btn; +#endif } - if(sign == LV_SIGNAL_CLEANUP) { + else if(sign == LV_SIGNAL_PRESS_LOST) { + lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn)); + lv_list_ext_t * ext = lv_obj_get_ext_attr(list); + ext->page.scroll_prop_ip = 0; + } + else if(sign == LV_SIGNAL_CLEANUP) { +#if USE_LV_GROUP lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn)); lv_obj_t * sel = lv_list_get_btn_selected(list); if(sel == btn) lv_list_set_btn_selected(list, lv_list_get_next_btn(list, btn)); +#endif } -#endif return res; } diff --git a/lv_objx/lv_list.h b/lv_objx/lv_list.h index a1ecaf3ce..f31a155a7 100644 --- a/lv_objx/lv_list.h +++ b/lv_objx/lv_list.h @@ -67,6 +67,7 @@ enum { LV_LIST_STYLE_BG, LV_LIST_STYLE_SCRL, LV_LIST_STYLE_SB, + LV_LIST_STYLE_EDGE_FLASH, LV_LIST_STYLE_BTN_REL, LV_LIST_STYLE_BTN_PR, LV_LIST_STYLE_BTN_TGL_REL, @@ -156,6 +157,16 @@ static inline void lv_list_set_scroll_propagation(lv_obj_t * list, bool en) lv_page_set_scroll_propagation(list, en); } +/** + * Enable the edge flash effect. (Show an arc when the an edge is reached) + * @param list pointer to a List + * @param en true or false to enable/disable end flash + */ +static inline void lv_list_set_edge_flash(lv_obj_t * list, bool en) +{ + lv_page_set_edge_flash(list, en); +} + /** * Set a style of a list * @param list pointer to a list object @@ -257,6 +268,16 @@ static inline bool lv_list_get_scroll_propagation(lv_obj_t * list) return lv_page_get_scroll_propagation(list); } +/** + * Get the scroll propagation property + * @param list pointer to a List + * @return true or false + */ +static inline bool lv_list_get_edge_flash(lv_obj_t * list) +{ + return lv_page_get_edge_flash(list); +} + /** * Get a style of a list * @param list pointer to a list object diff --git a/lv_objx/lv_page.c b/lv_objx/lv_page.c index d1f50567f..cd36c3143 100644 --- a/lv_objx/lv_page.c +++ b/lv_objx/lv_page.c @@ -19,8 +19,11 @@ /********************* * DEFINES *********************/ -#define LV_PAGE_SB_MIN_SIZE (LV_DPI / 8) -#define LV_PAGE_SCROLL_ANIM_TIME 200 /*[ms] Scroll anim time on `lv_page_scroll_up/down/left/rigth`*/ +#define LV_PAGE_SB_MIN_SIZE (LV_DPI / 8) +#define LV_PAGE_SCROLL_ANIM_TIME 200 /*[ms] Scroll anim time on `lv_page_scroll_up/down/left/rigth`*/ +#define LV_PAGE_END_FLASH_SIZE (LV_DPI / 4) +#define LV_PAGE_END_ANIM_TIME 300 +#define LV_PAGE_END_ANIM_WAIT_TIME 300 /********************** * TYPEDEFS @@ -34,6 +37,8 @@ static bool lv_page_design(lv_obj_t * page, const lv_area_t * mask, lv_design_mo static bool lv_scrl_design(lv_obj_t * scrl, const lv_area_t * mask, lv_design_mode_t mode); static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param); static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param); +static void edge_flash_anim(void * page, int32_t v); +static void edge_flash_anim_end(void * page); /********************** * STATIC VARIABLES @@ -79,6 +84,13 @@ lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy) ext->sb.ver_draw = 0; ext->sb.style = &lv_style_pretty; ext->sb.mode = LV_SB_MODE_AUTO; + ext->edge_flash.enabled = 0; + ext->edge_flash.bottom_ip = 0; + ext->edge_flash.top_ip = 0; + ext->edge_flash.left_ip = 0; + ext->edge_flash.right_ip = 0; + ext->edge_flash.state = 0; + ext->edge_flash.style = &lv_style_plain_color; ext->arrow_scroll = 0; ext->scroll_prop = 0; ext->scroll_prop_ip = 0; @@ -166,7 +178,7 @@ void lv_page_clean(lv_obj_t * obj) /** * Set a release action for the page * @param page pointer to a page object - * @param rel_action a function to call when the page is released + * @param rel_action a function to call when the page is release */ void lv_page_set_rel_action(lv_obj_t * page, lv_action_t rel_action) { @@ -231,6 +243,17 @@ void lv_page_set_scroll_propagation(lv_obj_t * page, bool en) ext->scroll_prop = en ? 1 : 0; } +/** + * Enable the edge flash effect. (Show an arc when the an edge is reached) + * @param page pointer to a Page + * @param en true or false to enable/disable end flash + */ +void lv_page_set_edge_flash(lv_obj_t * page, bool en) +{ + lv_page_ext_t * ext = lv_obj_get_ext_attr(page); + ext->edge_flash.enabled = en ? 1 : 0; +} + /** * Set a style of a page * @param page pointer to a page object @@ -256,6 +279,9 @@ void lv_page_set_style(lv_obj_t * page, lv_page_style_t type, lv_style_t * style lv_obj_refresh_ext_size(page); lv_obj_invalidate(page); break; + case LV_PAGE_STYLE_EDGE_FLASH: + ext->edge_flash.style = style; + break; } } @@ -330,6 +356,17 @@ bool lv_page_get_scroll_propagation(lv_obj_t * page) return ext->scroll_prop == 0 ? false : true; } +/** + * Get the edge flash effect property. + * @param page pointer to a Page + * return true or false + */ +bool lv_page_get_edge_flash(lv_obj_t * page) +{ + lv_page_ext_t * ext = lv_obj_get_ext_attr(page); + return ext->edge_flash.enabled == 0 ? false : true; +} + /** * Get that width which can be set to the children to still not cause overflow (show scrollbars) * @param page pointer to a page object @@ -377,6 +414,9 @@ lv_style_t * lv_page_get_style(const lv_obj_t * page, lv_page_style_t type) case LV_PAGE_STYLE_SB: style = ext->sb.style; break; + case LV_PAGE_STYLE_EDGE_FLASH: + style = ext->edge_flash.style; + break; default: style = NULL; break; @@ -531,6 +571,34 @@ void lv_page_scroll_ver(lv_obj_t * page, lv_coord_t dist) #endif } + +/** + * Not intended to use directly by the user but by other object types internally. + * Start an edge flash animation. Exactly one `ext->edge_flash.xxx_ip` should be set + * @param page + */ +void lv_page_start_edge_flash(lv_obj_t * page) +{ + lv_page_ext_t * ext = lv_obj_get_ext_attr(page); + if(ext->edge_flash.enabled) { + lv_anim_t a; + a.var = page; + a.start = 0; + a.end = LV_PAGE_END_FLASH_SIZE; + a.fp = (lv_anim_fp_t)edge_flash_anim; + a.path = lv_anim_path_linear; + a.end_cb = edge_flash_anim_end; + a.act_time = 0; + a.time = LV_PAGE_END_ANIM_TIME; + a.playback = 1; + a.playback_pause = LV_PAGE_END_ANIM_WAIT_TIME; + a.repeat = 0; + a.repeat_pause = 0; + lv_anim_create(&a); + } +} + + /********************** * STATIC FUNCTIONS **********************/ @@ -592,6 +660,46 @@ static bool lv_page_design(lv_obj_t * page, const lv_area_t * mask, lv_design_mo sb_area.y2 += page->coords.y1; lv_draw_rect(&sb_area, mask, ext->sb.style, lv_obj_get_opa_scale(page)); } + + + lv_coord_t page_w = lv_obj_get_width(page); + lv_coord_t page_h = lv_obj_get_height(page); + lv_area_t flash_area; + + if(ext->edge_flash.top_ip) { + flash_area.x1 = page->coords.x1 - page_w; + flash_area.x2 = page->coords.x2 + page_w; + flash_area.y1 = page->coords.y1 - 3 * page_w + ext->edge_flash.state; + flash_area.y2 = page->coords.y1 + ext->edge_flash.state; + } + else if(ext->edge_flash.bottom_ip) { + flash_area.x1 = page->coords.x1 - page_w; + flash_area.x2 = page->coords.x2 + page_w; + flash_area.y1 = page->coords.y2 - ext->edge_flash.state; + flash_area.y2 = page->coords.y2 + 3 * page_w - ext->edge_flash.state; + } + else if(ext->edge_flash.right_ip) { + flash_area.x1 = page->coords.x2 - ext->edge_flash.state; + flash_area.x2 = page->coords.x2 + 3 * page_h - ext->edge_flash.state; + flash_area.y1 = page->coords.y1 - page_h; + flash_area.y2 = page->coords.y2 + page_h; + } + else if(ext->edge_flash.left_ip) { + flash_area.x1 = page->coords.x1 - 3 * page_h + ext->edge_flash.state; + flash_area.x2 = page->coords.x1 + ext->edge_flash.state; + flash_area.y1 = page->coords.y1 - page_h; + flash_area.y2 = page->coords.y2 + page_h; + } + + if(ext->edge_flash.left_ip || ext->edge_flash.right_ip || ext->edge_flash.top_ip || ext->edge_flash.bottom_ip) { + lv_style_t flash_style; + lv_style_copy(&flash_style, ext->edge_flash.style); + flash_style.body.radius = LV_RADIUS_CIRCLE; + uint32_t opa = (flash_style.body.opa * ext->edge_flash.state) / LV_PAGE_END_FLASH_SIZE; + flash_style.body.opa = opa; + lv_draw_rect(&flash_area, mask, &flash_style, lv_obj_get_opa_scale(page)); + } + } return true; @@ -800,7 +908,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi } /*scrollable width smaller then page width? -> align to left*/ - if(lv_area_get_width(&scrl_coords) + 2 * hpad < lv_area_get_width(&page_coords)) { + if(lv_area_get_width(&scrl_coords) + 2 * hpad <= lv_area_get_width(&page_coords)) { if(scrl_coords.x1 != page_coords.x1 + hpad) { new_x = hpad; refr_x = true; @@ -817,15 +925,27 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi else if(scrl_coords.x2 < page_coords.x2 - hpad) { new_x = lv_area_get_width(&page_coords) - lv_area_get_width(&scrl_coords) - hpad; /* Right align */ refr_x = true; + if(page_ext->edge_flash.enabled && + page_ext->edge_flash.left_ip == 0 && page_ext->edge_flash.right_ip == 0 && + page_ext->edge_flash.top_ip == 0 && page_ext->edge_flash.bottom_ip == 0) { + lv_page_start_edge_flash(page); + page_ext->edge_flash.right_ip = 1; + } } else if(scrl_coords.x1 > page_coords.x1 + hpad) { new_x = hpad; /*Left align*/ refr_x = true; + if(page_ext->edge_flash.enabled && + page_ext->edge_flash.left_ip == 0 && page_ext->edge_flash.right_ip == 0 && + page_ext->edge_flash.top_ip == 0 && page_ext->edge_flash.bottom_ip == 0) { + lv_page_start_edge_flash(page); + page_ext->edge_flash.left_ip = 1; + } } } /*scrollable height smaller then page height? -> align to left*/ - if(lv_area_get_height(&scrl_coords) + 2 * vpad < lv_area_get_height(&page_coords)) { + if(lv_area_get_height(&scrl_coords) + 2 * vpad <= lv_area_get_height(&page_coords)) { if(scrl_coords.y1 != page_coords.y1 + vpad) { new_y = vpad; refr_y = true; @@ -842,10 +962,22 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi else if(scrl_coords.y2 < page_coords.y2 - vpad) { new_y = lv_area_get_height(&page_coords) - lv_area_get_height(&scrl_coords) - vpad; /* Bottom align */ refr_y = true; + if(page_ext->edge_flash.enabled && + page_ext->edge_flash.left_ip == 0 && page_ext->edge_flash.right_ip == 0 && + page_ext->edge_flash.top_ip == 0 && page_ext->edge_flash.bottom_ip == 0) { + lv_page_start_edge_flash(page); + page_ext->edge_flash.bottom_ip = 1; + } } else if(scrl_coords.y1 > page_coords.y1 + vpad) { new_y = vpad; /*Top align*/ refr_y = true; + if(page_ext->edge_flash.enabled && + page_ext->edge_flash.left_ip == 0 && page_ext->edge_flash.right_ip == 0 && + page_ext->edge_flash.top_ip == 0 && page_ext->edge_flash.bottom_ip == 0) { + lv_page_start_edge_flash(page); + page_ext->edge_flash.top_ip = 1; + } } } @@ -1017,4 +1149,21 @@ static void lv_page_sb_refresh(lv_obj_t * page) } } +static void edge_flash_anim(void * page, int32_t v) +{ + lv_page_ext_t * ext = lv_obj_get_ext_attr(page); + ext->edge_flash.state = v; + lv_obj_invalidate(page); +} + +static void edge_flash_anim_end(void * page) +{ + lv_page_ext_t * ext = lv_obj_get_ext_attr(page); + ext->edge_flash.top_ip = 0; + ext->edge_flash.bottom_ip = 0; + ext->edge_flash.left_ip = 0; + ext->edge_flash.right_ip = 0; + lv_obj_invalidate(page); +} + #endif diff --git a/lv_objx/lv_page.h b/lv_objx/lv_page.h index 5a21729c9..32f6104db 100644 --- a/lv_objx/lv_page.h +++ b/lv_objx/lv_page.h @@ -65,6 +65,16 @@ typedef struct uint8_t ver_draw :1; /*1: vertical scrollbar is visible now (Handled by the library)*/ lv_sb_mode_t mode:3; /*Scrollbar visibility from 'lv_page_sb_mode_t'*/ } sb; + struct { + uint16_t state; /*Store the current size of the edge flash effect*/ + lv_style_t *style; /*Style of edge flash effect (usually homogeneous circle)*/ + uint8_t enabled :1; /*1: Show a flash animation on the edge*/ + uint8_t top_ip :1; /*Used internally to show that top most position is reached (flash is In Progress)*/ + uint8_t bottom_ip :1; /*Used internally to show that bottom most position is reached (flash is In Progress)*/ + uint8_t right_ip :1; /*Used internally to show that right most position is reached (flash is In Progress)*/ + uint8_t left_ip :1; /*Used internally to show that left most position is reached (flash is In Progress)*/ + }edge_flash; + uint8_t arrow_scroll :1; /*1: Enable scrolling with LV_GROUP_KEY_LEFT/RIGHT/UP/DOWN*/ uint8_t scroll_prop :1; /*1: Propagate the scrolling the the parent if the edge is reached*/ uint8_t scroll_prop_ip :1; /*1: Scroll propagation is in progress (used by the library)*/ @@ -74,6 +84,7 @@ enum { LV_PAGE_STYLE_BG, LV_PAGE_STYLE_SCRL, LV_PAGE_STYLE_SB, + LV_PAGE_STYLE_EDGE_FLASH, }; typedef uint8_t lv_page_style_t; @@ -155,6 +166,13 @@ void lv_page_set_arrow_scroll(lv_obj_t * page, bool en); */ void lv_page_set_scroll_propagation(lv_obj_t * page, bool en); +/** + * Enable the edge flash effect. (Show an arc when the an edge is reached) + * @param page pointer to a Page + * @param en true or false to enable/disable end flash + */ +void lv_page_set_edge_flash(lv_obj_t * page, bool en); + /** * Set the fit attribute of the scrollable part of a page. * It means it can set its size automatically to involve all children. @@ -233,6 +251,13 @@ bool lv_page_get_arrow_scroll(const lv_obj_t * page); */ bool lv_page_get_scroll_propagation(lv_obj_t * page); +/** + * Get the edge flash effect property. + * @param page pointer to a Page + * return true or false + */ +bool lv_page_get_edge_flash(lv_obj_t * page); + /** * Get that width which can be set to the children to still not cause overflow (show scrollbars) * @param page pointer to a page object @@ -338,6 +363,12 @@ void lv_page_scroll_hor(lv_obj_t * page, lv_coord_t dist); */ void lv_page_scroll_ver(lv_obj_t * page, lv_coord_t dist); +/** + * Not intended to use directly by the user but by other object types internally. + * Start an edge flash animation. Exactly one `ext->edge_flash.xxx_ip` should be set + * @param page + */ +void lv_page_start_edge_flash(lv_obj_t * page); /********************** * MACROS **********************/ diff --git a/lv_objx/lv_ta.c b/lv_objx/lv_ta.c index 5e06492a9..f3dd9e7ee 100644 --- a/lv_objx/lv_ta.c +++ b/lv_objx/lv_ta.c @@ -199,6 +199,10 @@ void lv_ta_add_char(lv_obj_t * ta, uint32_t c) return; } + /*Disable edge flash. If a new line was added it could show edge flash effect*/ + bool edge_flash_en = lv_ta_get_edge_flash(ta); + lv_ta_set_edge_flash(ta, false); + if(ext->pwd_mode != 0) pwd_char_hider(ta); /*Make sure all the current text contains only '*'*/ uint32_t letter_buf[2]; letter_buf[0] = c; @@ -237,6 +241,9 @@ void lv_ta_add_char(lv_obj_t * ta, uint32_t c) /*Move the cursor after the new character*/ lv_ta_set_cursor_pos(ta, lv_ta_get_cursor_pos(ta) + 1); + + /*Revert the original edge flash state*/ + lv_ta_set_edge_flash(ta, edge_flash_en); } /** @@ -260,6 +267,10 @@ void lv_ta_add_text(lv_obj_t * ta, const char * txt) return; } + /*Disable edge flash. If a new line was added it could show edge flash effect*/ + bool edge_flash_en = lv_ta_get_edge_flash(ta); + lv_ta_set_edge_flash(ta, false); + /*Insert the text*/ lv_label_ins_text(ext->label, ext->cursor.pos, txt); @@ -293,6 +304,9 @@ void lv_ta_add_text(lv_obj_t * ta, const char * txt) /*Move the cursor after the new text*/ lv_ta_set_cursor_pos(ta, lv_ta_get_cursor_pos(ta) + lv_txt_get_encoded_length(txt)); + + /*Revert the original edge flash state*/ + lv_ta_set_edge_flash(ta, edge_flash_en); } /** @@ -632,6 +646,9 @@ void lv_ta_set_style(lv_obj_t * ta, lv_ta_style_t type, lv_style_t * style) case LV_TA_STYLE_SB: lv_page_set_style(ta, LV_PAGE_STYLE_SB, style); break; + case LV_TA_STYLE_EDGE_FLASH: + lv_page_set_style(ta, LV_PAGE_STYLE_EDGE_FLASH, style); + break; case LV_TA_STYLE_CURSOR: ext->cursor.style = style; lv_obj_refresh_ext_size(lv_page_get_scrl(ta)); /*Refresh ext. size because of cursor drawing*/ @@ -760,6 +777,9 @@ lv_style_t * lv_ta_get_style(const lv_obj_t * ta, lv_ta_style_t type) case LV_TA_STYLE_SB: style = lv_page_get_style(ta, LV_PAGE_STYLE_SB); break; + case LV_TA_STYLE_EDGE_FLASH: + style = lv_page_get_style(ta, LV_PAGE_STYLE_EDGE_FLASH); + break; case LV_TA_STYLE_CURSOR: style = ext->cursor.style; break; diff --git a/lv_objx/lv_ta.h b/lv_objx/lv_ta.h index 230807a40..d4aed43fa 100644 --- a/lv_objx/lv_ta.h +++ b/lv_objx/lv_ta.h @@ -76,6 +76,7 @@ typedef struct enum { LV_TA_STYLE_BG, LV_TA_STYLE_SB, + LV_TA_STYLE_EDGE_FLASH, LV_TA_STYLE_CURSOR, }; typedef uint8_t lv_ta_style_t; @@ -213,6 +214,16 @@ static inline void lv_ta_set_scroll_propagation(lv_obj_t * ta, bool en) lv_page_set_scroll_propagation(ta, en); } +/** + * Enable the edge flash effect. (Show an arc when the an edge is reached) + * @param page pointer to a Text Area + * @param en true or false to enable/disable end flash + */ +static inline void lv_ta_set_edge_flash(lv_obj_t * ta, bool en) +{ + lv_page_set_edge_flash(ta, en); +} + /** * Set a style of a text area * @param ta pointer to a text area object @@ -318,6 +329,16 @@ static inline bool lv_ta_get_scroll_propagation(lv_obj_t * ta) return lv_page_get_scroll_propagation(ta); } +/** + * Get the scroll propagation property + * @param ta pointer to a Text area + * @return true or false + */ +static inline bool lv_ta_get_edge_flash(lv_obj_t * ta) +{ + return lv_page_get_edge_flash(ta); +} + /** * Get a style of a text area * @param ta pointer to a text area object diff --git a/lv_objx/lv_tileview.c b/lv_objx/lv_tileview.c new file mode 100644 index 000000000..92aeeb8cd --- /dev/null +++ b/lv_objx/lv_tileview.c @@ -0,0 +1,571 @@ +/** + * @file lv_tileview.c + * + */ + +/********************* + * INCLUDES + *********************/ +#include "lv_tileview.h" +#if USE_LV_TILEVIEW != 0 + +#include +#include "lv_cont.h" + +/********************* + * DEFINES + *********************/ +#if USE_LV_ANIMATION +# ifndef LV_TILEVIEW_ANIM_TIME +# define LV_TILEVIEW_ANIM_TIME 300 /*Animation time loading a tile [ms] (0: no animation) */ +# endif +#else +# undef LV_TILEVIEW_ANIM_TIME +# define LV_TILEVIEW_ANIM_TIME 0 /*No animations*/ +#endif + +/********************** + * TYPEDEFS + **********************/ + +/********************** + * STATIC PROTOTYPES + **********************/ +static lv_res_t lv_tileview_signal(lv_obj_t * tileview, lv_signal_t sign, void * param); +static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param); +static lv_res_t element_signal_func(lv_obj_t * element, lv_signal_t sign, void * param); +static void drag_end_handler(lv_obj_t * tileview); +static bool set_valid_drag_dirs(lv_obj_t * tileview); + +/********************** + * STATIC VARIABLES + **********************/ +static lv_signal_func_t ancestor_signal; +static lv_signal_func_t ancestor_scrl_signal; +static lv_design_func_t ancestor_design; + +/********************** + * MACROS + **********************/ + +/********************** + * GLOBAL FUNCTIONS + **********************/ + +/** + * Create a tileview object + * @param par pointer to an object, it will be the parent of the new tileview + * @param copy pointer to a tileview object, if not NULL then the new object will be copied from it + * @return pointer to the created tileview + */ +lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy) +{ + LV_LOG_TRACE("tileview create started"); + + /*Create the ancestor of tileview*/ + lv_obj_t * new_tileview = lv_page_create(par, copy); + lv_mem_assert(new_tileview); + if(new_tileview == NULL) return NULL; + + /*Allocate the tileview type specific extended data*/ + lv_tileview_ext_t * ext = lv_obj_allocate_ext_attr(new_tileview, sizeof(lv_tileview_ext_t)); + lv_mem_assert(ext); + if(ext == NULL) return NULL; + if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_tileview); + if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_func(lv_page_get_scrl(new_tileview)); + if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_func(new_tileview); + + /*Initialize the allocated 'ext' */ + ext->anim_time = LV_TILEVIEW_ANIM_TIME; + ext->action = NULL; + ext->act_id.x = 0; + ext->act_id.y = 0; + ext->valid_pos = NULL; + + /*The signal and design functions are not copied so set them here*/ + lv_obj_set_signal_func(new_tileview, lv_tileview_signal); + lv_obj_set_signal_func(lv_page_get_scrl(new_tileview), lv_tileview_scrl_signal); + + /*Init the new tileview*/ + if(copy == NULL) { + lv_obj_set_size(new_tileview, LV_HOR_RES, LV_VER_RES); + + lv_obj_set_drag_throw(lv_page_get_scrl(new_tileview), false); + lv_page_set_scrl_fit(new_tileview, true, true); + lv_page_set_style(new_tileview, LV_PAGE_STYLE_BG, &lv_style_transp_tight); + lv_page_set_style(new_tileview, LV_PAGE_STYLE_SCRL, &lv_style_transp_tight); + } + /*Copy an existing tileview*/ + else { + lv_tileview_ext_t * copy_ext = lv_obj_get_ext_attr(copy); + ext->act_id.x = copy_ext->act_id.x; + ext->act_id.y = copy_ext->act_id.y; + ext->action = copy_ext->action; + ext->anim_time = copy_ext->anim_time; + + + /*Refresh the style with new signal function*/ + lv_obj_refresh_style(new_tileview); + } + + LV_LOG_INFO("tileview created"); + + return new_tileview; +} + +/*====================== + * Add/remove functions + *=====================*/ + +/** + * Register an object on the tileview. The register object will able to slide the tileview + * @param tileview pointer to a tileview object + * @param element pointer to an object + */ +void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element) +{ + (void) tileview; /*Unused*/ + lv_obj_set_free_ptr(element, lv_obj_get_signal_func(element)); + lv_obj_set_signal_func(element, element_signal_func); + lv_obj_set_drag_parent(element, true); +} + + +/*===================== + * Setter functions + *====================*/ + +/** + * Set the valid position's indices. The scrolling will be possible only to these positions. + * @param tileview pointer to a Tileview object + * @param valid_pos array width the indices. E.g. `lv_point_t p[] = {{0,0}, {1,0}, {1,1}, {LV_COORD_MIN, LV_COORD_MIN}};` + * Must be closed with `{LV_COORD_MIN, LV_COORD_MIN}`. Only the pointer is saved so can't be a local variable. + */ +void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t * valid_pos) +{ + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + ext->valid_pos = valid_pos; +} + +/** + * Set the tile to be shown + * @param tileview pointer to a tileview object + * @param x column id (0, 1, 2...) + * @param y line id (0, 1, 2...) + * @param anim_en true: move with animation + */ +void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, bool anim_en) +{ +#if USE_LV_ANIMATION == 0 + anim_en = false; +#endif + + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + + + uint16_t i; + bool valid = false; + for(i = 0; ext->valid_pos[i].x != LV_COORD_MIN; i++) { + if(ext->valid_pos[i].x == x && ext->valid_pos[i].y == y) { + valid = true; + } + } + + if(valid == false) return; /*Don't load not valid tiles*/ + + lv_res_t res = LV_RES_OK; + if(ext->action) res = ext->action(tileview, x, y); + if(res != LV_RES_OK) return; /*Prevent the tile loading*/ + + ext->act_id.x = x; + ext->act_id.y = y; + + lv_coord_t x_coord = -x * lv_obj_get_width(tileview); + lv_coord_t y_coord = -y * lv_obj_get_height(tileview); + lv_obj_t * scrl = lv_page_get_scrl(tileview); + if(anim_en) { +#if USE_LV_ANIMATION + lv_coord_t x_act = lv_obj_get_x(scrl); + lv_coord_t y_act = lv_obj_get_y(scrl); + + lv_anim_t a; + a.var = scrl; + a.fp = (lv_anim_fp_t)lv_obj_set_x; + a.path = lv_anim_path_linear; + a.end_cb = NULL; + a.act_time = 0; + a.time = ext->anim_time; + a.playback = 0; + a.playback_pause = 0; + a.repeat = 0; + a.repeat_pause = 0; + + if(x_coord != x_act) { + a.start = x_act; + a.end = x_coord; + lv_anim_create(&a); + } + + if(y_coord != y_act) { + a.start = y_act; + a.end = y_coord; + a.fp = (lv_anim_fp_t)lv_obj_set_y; + lv_anim_create(&a); + } +#endif + } else { + lv_obj_set_size(tileview, x_coord, y_coord); + } +} + +void lv_tileview_set_tile_load_action(lv_obj_t * tileview, lv_tileview_action_t action) +{ + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + ext->action = action; + +} + +/** + * Set a style of a tileview. + * @param tileview pointer to tileview object + * @param type which style should be set + * @param style pointer to a style + */ +void lv_tileview_set_style(lv_obj_t * tileview, lv_tileview_style_t type, lv_style_t * style) +{ + + switch(type) { + case LV_TILEVIEW_STYLE_BG: + lv_obj_set_style(tileview, style); + break; + } +} + +/*===================== + * Getter functions + *====================*/ + +/* + * New object specific "get" functions come here + */ + +/** + * Get style of a tileview. + * @param tileview pointer to tileview object + * @param type which style should be get + * @return style pointer to the style + */ +lv_style_t * lv_tileview_get_style(const lv_obj_t * tileview, lv_tileview_style_t type) +{ + lv_style_t * style = NULL; + switch(type) { + case LV_TILEVIEW_STYLE_BG: + style = lv_obj_get_style(tileview); + break; + default: + style = NULL; + } + + return style; +} + +/*===================== + * Other functions + *====================*/ + +/* + * New object specific "other" functions come here + */ + +/********************** + * STATIC FUNCTIONS + **********************/ + +/** + * Signal function of the tileview + * @param tileview pointer to a tileview object + * @param sign a signal type from lv_signal_t enum + * @param param pointer to a signal specific variable + * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted + */ +static lv_res_t lv_tileview_signal(lv_obj_t * tileview, lv_signal_t sign, void * param) +{ + lv_res_t res; + + /* Include the ancient signal function */ + res = ancestor_signal(tileview, sign, param); + if(res != LV_RES_OK) return res; + + + if(sign == LV_SIGNAL_CLEANUP) { + /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/ + } else if(sign == LV_SIGNAL_GET_TYPE) { + lv_obj_type_t * buf = param; + uint8_t i; + for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) { /*Find the last set data*/ + if(buf->type[i] == NULL) break; + } + buf->type[i] = "lv_tileview"; + } + + return res; +} + +/** + * Signal function of the tileview scrollable + * @param tileview pointer to the scrollable part of the tileview object + * @param sign a signal type from lv_signal_t enum + * @param param pointer to a signal specific variable + * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted + */ +static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param) +{ + + lv_res_t res; + + /* Include the ancient signal function */ + res = ancestor_scrl_signal(scrl, sign, param); + if(res != LV_RES_OK) return res; + + lv_obj_t * tileview = lv_obj_get_parent(scrl); + + /*Apply constraint on moving of the tileview*/ + if(sign == LV_SIGNAL_CORD_CHG) { + lv_indev_t * indev = lv_indev_get_act(); + if(indev) { + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + + /*Set horizontal drag constraint if no vertical constraint an dragged to valid x direction */ + if(ext->drag_ver == 0 && + ((ext->drag_right_en && indev->proc.drag_sum.x <= -LV_INDEV_DRAG_LIMIT) || + (ext->drag_left_en && indev->proc.drag_sum.x >= LV_INDEV_DRAG_LIMIT))) { + ext->drag_hor = 1; + } + /*Set vertical drag constraint if no horizontal constraint an dragged to valid y direction */ + if(ext->drag_hor == 0 && + ((ext->drag_bottom_en && indev->proc.drag_sum.y <= -LV_INDEV_DRAG_LIMIT) || + (ext->drag_top_en && indev->proc.drag_sum.y >= LV_INDEV_DRAG_LIMIT))) { + ext->drag_ver = 1; + } + + if(ext->drag_hor) { + ext->page.edge_flash.top_ip = 0; + ext->page.edge_flash.bottom_ip = 0; + } + + if(ext->drag_ver) { + ext->page.edge_flash.right_ip = 0; + ext->page.edge_flash.left_ip = 0; + } + + lv_coord_t x = lv_obj_get_x(scrl); + lv_coord_t y = lv_obj_get_y(scrl); + lv_coord_t h = lv_obj_get_height(tileview); + lv_coord_t w = lv_obj_get_width(tileview); + if(ext->drag_top_en == 0) { + if(y > -(ext->act_id.y * h) && indev->proc.vect.y > 0 && ext->drag_hor == 0) { + if(ext->page.edge_flash.enabled && + ext->page.edge_flash.left_ip == 0 && ext->page.edge_flash.right_ip == 0 && + ext->page.edge_flash.top_ip == 0 && ext->page.edge_flash.bottom_ip == 0) { + ext->page.edge_flash.top_ip = 1; + lv_page_start_edge_flash(tileview); + } + + lv_obj_set_y(scrl, -ext->act_id.y * h); + } + } + if(ext->drag_bottom_en == 0 && indev->proc.vect.y < 0 && ext->drag_hor == 0) { + if(y < -(ext->act_id.y * h)) { + if(ext->page.edge_flash.enabled && + ext->page.edge_flash.left_ip == 0 && ext->page.edge_flash.right_ip == 0 && + ext->page.edge_flash.top_ip == 0 && ext->page.edge_flash.bottom_ip == 0) { + ext->page.edge_flash.bottom_ip = 1; + lv_page_start_edge_flash(tileview); + } + } + + lv_obj_set_y(scrl, -ext->act_id.y * h); + } + if(ext->drag_left_en == 0) { + if(x > -(ext->act_id.x * w) && indev->proc.vect.x > 0 && ext->drag_ver == 0) { + if(ext->page.edge_flash.enabled && + ext->page.edge_flash.left_ip == 0 && ext->page.edge_flash.right_ip == 0 && + ext->page.edge_flash.top_ip == 0 && ext->page.edge_flash.bottom_ip == 0) { + ext->page.edge_flash.left_ip = 1; + lv_page_start_edge_flash(tileview); + } + + lv_obj_set_x(scrl, -ext->act_id.x * w); + } + } + if(ext->drag_right_en == 0 && indev->proc.vect.x < 0 && ext->drag_ver == 0) { + if(x < -(ext->act_id.x * w)) { + if(ext->page.edge_flash.enabled && + ext->page.edge_flash.left_ip == 0 && ext->page.edge_flash.right_ip == 0 && + ext->page.edge_flash.top_ip == 0 && ext->page.edge_flash.bottom_ip == 0) { + ext->page.edge_flash.right_ip = 1; + lv_page_start_edge_flash(tileview); + } + } + + lv_obj_set_x(scrl, -ext->act_id.x * w); + } + + /*Apply the drag constraints*/ + if(ext->drag_ver == 0) lv_obj_set_y(scrl, - ext->act_id.y * lv_obj_get_height(tileview)); + if(ext->drag_hor == 0) lv_obj_set_x(scrl, - ext->act_id.x * lv_obj_get_width(tileview)); + } + } + + return res; + +} + +/** + * This function is applied called for the elements of the tileview. Used when the element is + * @param element + * @param sign + * @param param + * @return + */ +static lv_res_t element_signal_func(lv_obj_t * element, lv_signal_t sign, void * param) +{ + lv_res_t res; + + /* Include the ancient signal function */ + lv_signal_func_t sign_func = lv_obj_get_free_ptr(element); + res = sign_func(element, sign, param); + if(res != LV_RES_OK) return res; + + /*Initialize some variables on PRESS*/ + if(sign == LV_SIGNAL_PRESSED) { + /*Get the tileview from the element*/ + lv_obj_t * tileview = lv_obj_get_parent(element); + while(tileview) { + if(lv_obj_get_signal_func(tileview) != lv_tileview_signal) tileview = lv_obj_get_parent(tileview); + else break; + } + + if(tileview) { + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + ext->drag_hor = 0; + ext->drag_ver = 0; + set_valid_drag_dirs(tileview); + } + } + + /*Animate the tabview to the correct location on RELEASE*/ + else if(sign == LV_SIGNAL_PRESS_LOST || sign == LV_SIGNAL_RELEASED) { + + /*Get the tileview from the element*/ + lv_obj_t * tileview = lv_obj_get_parent(element); + while(tileview) { + if(lv_obj_get_signal_func(tileview) != lv_tileview_signal) tileview = lv_obj_get_parent(tileview); + else break; + } + + if(tileview) { + /* If the element was dragged and it moved the tileview finish the drag manually to + * let the tileview to finish the move.*/ + lv_indev_t * indev = lv_indev_get_act(); + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + if(indev->proc.drag_in_prog && (ext->drag_hor || ext->drag_ver)) { + + lv_obj_t * drag_obj = element; + while(lv_obj_get_drag_parent(drag_obj)) { + drag_obj = lv_obj_get_parent(drag_obj); + if(drag_obj == NULL) break; + } + indev->proc.drag_in_prog = 0; + if(drag_obj) drag_obj->signal_func(drag_obj, LV_SIGNAL_DRAG_END, NULL); + } + + drag_end_handler(tileview); + } + } + + return res; +} + +/** + * Called when the user releases an element of the tileview after dragging it. + * @param tileview pointer to a tileview object + */ +static void drag_end_handler(lv_obj_t * tileview) +{ + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + lv_indev_t * indev = lv_indev_get_act(); + lv_point_t point_act; + lv_indev_get_point(indev, &point_act); + lv_obj_t * scrl = lv_page_get_scrl(tileview); + lv_point_t p; + + p.x = - (scrl->coords.x1 - LV_HOR_RES / 2); + p.y = - (scrl->coords.y1 - LV_VER_RES / 2); + + /*From the drag vector (drag throw) predict the end position*/ + if(ext->drag_hor) { + lv_point_t vect; + lv_indev_get_vect(indev, &vect); + lv_coord_t predict = 0; + + while(vect.x != 0) { + predict += vect.x; + vect.x = vect.x * (100 - LV_INDEV_DRAG_THROW) / 100; + } + + p.x -= predict; + } + else if(ext->drag_ver) { + lv_point_t vect; + lv_indev_get_vect(indev, &vect); + lv_coord_t predict = 0; + + while(vect.y != 0) { + predict += vect.y; + vect.y = vect.y * (100 - LV_INDEV_DRAG_THROW) / 100; + } + + p.y -= predict; + } + + /*Get the index of the tile*/ + p.x = p.x / lv_obj_get_width(tileview); + p.y = p.y / lv_obj_get_height(tileview); + + /*Max +- move*/ + lv_coord_t x_move = p.x - ext->act_id.x; + lv_coord_t y_move = p.y - ext->act_id.y; + if(x_move < -1) x_move = -1; + if(x_move > 1) x_move = 1; + if(y_move < -1) y_move = -1; + if(y_move > 1) y_move = 1; + + /*Set the new tile*/ + lv_tileview_set_tile_act(tileview, ext->act_id.x + x_move, ext->act_id.y + y_move,true); +} + +static bool set_valid_drag_dirs(lv_obj_t * tileview) +{ + + lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); + if(ext->valid_pos == NULL) return false; + + ext->drag_bottom_en = 0; + ext->drag_top_en = 0; + ext->drag_left_en = 0; + ext->drag_right_en = 0; + + uint16_t i; + for(i = 0; ext->valid_pos[i].x != LV_COORD_MIN; i++) { + if(ext->valid_pos[i].x == ext->act_id.x && ext->valid_pos[i].y == ext->act_id.y - 1) ext->drag_top_en = 1; + if(ext->valid_pos[i].x == ext->act_id.x && ext->valid_pos[i].y == ext->act_id.y + 1) ext->drag_bottom_en = 1; + if(ext->valid_pos[i].x == ext->act_id.x - 1 && ext->valid_pos[i].y == ext->act_id.y) ext->drag_left_en = 1; + if(ext->valid_pos[i].x == ext->act_id.x + 1 && ext->valid_pos[i].y == ext->act_id.y) ext->drag_right_en = 1; + } + + return true; +} + + +#endif diff --git a/lv_objx/lv_tileview.h b/lv_objx/lv_tileview.h new file mode 100644 index 000000000..7a479e1de --- /dev/null +++ b/lv_objx/lv_tileview.h @@ -0,0 +1,164 @@ +/** + * @file lv_tileview.h + * + */ + + +#ifndef LV_TILEVIEW_H +#define LV_TILEVIEW_H + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ +#ifdef LV_CONF_INCLUDE_SIMPLE +#include "lv_conf.h" +#else +#include "../../lv_conf.h" +#endif + +#if USE_LV_TILEVIEW != 0 + +#include "../lv_objx/lv_page.h" + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + + + +/* parametes: pointer to a tileview object, x, y (tile coordinates to load) + * return: LV_RES_INV: to prevent the loading of the tab; LV_RES_OK: if everything is fine*/ +typedef lv_res_t (*lv_tileview_action_t)(lv_obj_t *, lv_coord_t, lv_coord_t); + +/*Data of tileview*/ +typedef struct { + lv_page_ext_t page; + /*New data for this type */ + const lv_point_t * valid_pos; + uint16_t anim_time; + lv_tileview_action_t action; + lv_point_t act_id; + uint8_t drag_top_en :1; + uint8_t drag_bottom_en :1; + uint8_t drag_left_en :1; + uint8_t drag_right_en :1; + uint8_t drag_hor :1; + uint8_t drag_ver :1; +} lv_tileview_ext_t; + + +/*Styles*/ +enum { + LV_TILEVIEW_STYLE_BG, +}; +typedef uint8_t lv_tileview_style_t; + + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +/** + * Create a tileview objects + * @param par pointer to an object, it will be the parent of the new tileview + * @param copy pointer to a tileview object, if not NULL then the new object will be copied from it + * @return pointer to the created tileview + */ +lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy); + +/*====================== + * Add/remove functions + *=====================*/ + +/** + * Register an object on the tileview. The register object will able to slide the tileview + * @param tileview pointer to a tileview object + * @param element pointer to an object + */ +void lv_tileview_add_element(lv_obj_t * tileview, lv_obj_t * element); + +/*===================== + * Setter functions + *====================*/ + + +/** + * Set the valid position's indices. The scrolling will be possible only to these positions. + * @param tileview pointer to a Tileview object + * @param valid_pos array width the indices. E.g. `lv_point_t p[] = {{0,0}, {1,0}, {1,1}, {LV_COORD_MIN, LV_COORD_MIN}};` + * Must be closed with `{LV_COORD_MIN, LV_COORD_MIN}`. Only the pointer is saved so can't be a local variable. + */ +void lv_tileview_set_valid_positions(lv_obj_t * tileview, const lv_point_t * valid_pos); + +/** + * Set the tile to be shown + * @param tileview pointer to a tileview object + * @param x column id (0, 1, 2...) + * @param y line id (0, 1, 2...) + * @param anim_en true: move with animation + */ +void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, bool anim_en); + +/** + * Enable the edge flash effect. (Show an arc when the an edge is reached) + * @param tileview pointer to a Tileview + * @param en true or false to enable/disable end flash + */ +static inline void lv_tileview_set_edge_flash(lv_obj_t * tileview, bool en) +{ + lv_page_set_edge_flash(tileview, en); +} + +/** + * Set a style of a tileview. + * @param tileview pointer to tileview object + * @param type which style should be set + * @param style pointer to a style + */ +void lv_tileview_set_style(lv_obj_t * tileview, lv_tileview_style_t type, lv_style_t *style); + +/*===================== + * Getter functions + *====================*/ + +/** + * Get the scroll propagation property + * @param tileview pointer to a Tileview + * @return true or false + */ +static inline bool lv_tileview_get_edge_flash(lv_obj_t * tileview) +{ + return lv_page_get_edge_flash(tileview); +} + +/** + * Get style of a tileview. + * @param tileview pointer to tileview object + * @param type which style should be get + * @return style pointer to the style + */ +lv_style_t * lv_tileview_get_style(const lv_obj_t * tileview, lv_tileview_style_t type); + +/*===================== + * Other functions + *====================*/ + +/********************** + * MACROS + **********************/ + +#endif /*USE_LV_TILEVIEW*/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /*LV_TILEVIEW_H*/ diff --git a/lvgl.h b/lvgl.h index 7d7e37e0d..dfaf55a92 100644 --- a/lvgl.h +++ b/lvgl.h @@ -47,6 +47,7 @@ extern "C" { #include "lv_objx/lv_ta.h" #include "lv_objx/lv_win.h" #include "lv_objx/lv_tabview.h" +#include "lv_objx/lv_tileview.h" #include "lv_objx/lv_mbox.h" #include "lv_objx/lv_gauge.h" #include "lv_objx/lv_lmeter.h"