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

rework roller

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2020-09-27 22:10:08 +02:00
parent f3085bf191
commit f5dc2e4248
11 changed files with 204 additions and 471 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
src/lv_api_map.h
View File

@@ -27,161 +27,6 @@ extern "C" {
* GLOBAL PROTOTYPES
**********************/
/*---------------------
* V6.0 COMPATIBILITY
*--------------------*/
#if LV_USE_API_EXTENSION_V6
static inline void lv_task_once(lv_task_t * task)
{
lv_task_set_repeat_count(task, 1);
}
#if LV_USE_CHECKBOX
#define lv_checkbox_set_static_text lv_checkbox_set_text_static
#endif
#if LV_USE_CHART
#define lv_chart_get_point_cnt lv_chart_get_point_count
#endif
#if LV_USE_DROPDOWN
static inline void lv_dropdown_set_draw_arrow(lv_obj_t * ddlist, bool en)
{
if(en) lv_dropdown_set_symbol(ddlist, LV_SYMBOL_DOWN);
else lv_dropdown_set_symbol(ddlist, NULL);
}
static inline bool lv_dropdown_get_draw_arrow(lv_obj_t * ddlist)
{
if(lv_dropdown_get_symbol(ddlist)) return true;
else return false;
}
#define lv_dropdown_set_static_options lv_dropdown_set_options_static
#endif
#if LV_USE_BAR
/**
* Make the bar symmetric to zero. The indicator will grow from zero instead of the minimum
* position.
* @param bar pointer to a bar object
* @param en true: enable disable symmetric behavior; false: disable
* @deprecated As of v7.0, you should use `lv_bar_set_type` instead.
*/
static inline void lv_bar_set_sym(lv_obj_t * bar, bool en)
{
if(en)
lv_bar_set_type(bar, LV_BAR_TYPE_SYMMETRICAL);
else
lv_bar_set_type(bar, LV_BAR_TYPE_NORMAL);
}
/**
* Get whether the bar is symmetric or not.
* @param bar pointer to a bar object
* @return true: symmetric is enabled; false: disable
* @deprecated As of v7.0, you should use `lv_bar_get_type` instead.
*/
static inline bool lv_bar_get_sym(lv_obj_t * bar)
{
return lv_bar_get_type(bar) == LV_BAR_TYPE_SYMMETRICAL;
}
#endif
#if LV_USE_LABEL
#define lv_label_set_static_text lv_label_set_text_static
#endif
#if LV_USE_SLIDER
/**
* Make the slider symmetric to zero. The indicator will grow from zero instead of the minimum
* position.
* @param slider pointer to a bar object
* @param en true: enable disable symmetric behavior; false: disable
* @deprecated As of v7.0, you should use `lv_slider_set_type` instead.
*/
static inline void lv_slider_set_sym(lv_obj_t * slider, bool en)
{
lv_bar_set_sym(slider, en);
}
/**
* Get whether the slider is symmetric or not.
* @param slider pointer to a slider object
* @return true: symmetric is enabled; false: disable
* @deprecated As of v7.0, you should use `lv_slider_get_type` instead.
*/
static inline bool lv_slider_get_sym(lv_obj_t * slider)
{
return lv_bar_get_sym(slider);
}
#endif
#if LV_USE_ROLLER
/**
* Set a fixed width for the roller.
* @param roller pointer to a roller object
* @param w width
* @deprecated As of v7.0, you should use `lv_roller_set_auto_fit` and set the width normally instead.
*/
static inline void lv_roller_set_fix_width(lv_obj_t * roller, lv_coord_t w)
{
lv_roller_set_auto_fit(roller, false);
lv_obj_set_width(roller, w);
}
#endif
#if LV_USE_PAGE
#define lv_scrlbar_mode_t lv_scrollbar_mode_t
#define LV_SCRLBAR_MODE_OFF LV_SCROLLBAR_MODE_OFF
#define LV_SCRLBAR_MODE_ON LV_SCROLLBAR_MODE_ON
#define LV_SCRLBAR_MODE_DRAG LV_SCROLLBAR_MODE_DRAG
#define LV_SCRLBAR_MODE_AUTO LV_SCROLLBAR_MODE_AUTO
#define LV_SCRLBAR_MODE_HIDE LV_SCROLLBAR_MODE_HIDE
#define LV_SCRLBAR_MODE_UNHIDE LV_SCROLLBAR_MODE_UNHIDE
static inline void lv_page_set_scrlbar_mode(lv_obj_t * page, lv_scrlbar_mode_t sb_mode)
{
lv_page_set_scrollbar_mode(page, sb_mode);
}
static inline lv_scrollbar_mode_t lv_page_get_scrlbar_mode(lv_obj_t * page)
{
return lv_page_get_scrollbar_mode(page);
}
static inline lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
{
return lv_page_get_scrollable(page);
}
#endif
#endif /*LV_USE_API_EXTENSION_V6*/
/*---------------------
* V7.0 COMPATIBILITY
*--------------------*/

10
src/lv_core/lv_indev.c
View File

@@ -991,16 +991,6 @@ static void indev_proc_release(lv_indev_proc_t * proc)
lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
if(indev_reset_check(proc)) return;
/*Send SCROLL_THROW_BEGIN signal and event*/
if(scroll_obj) {
lv_signal_send(scroll_obj, LV_SIGNAL_SCROLL_THROW_BEGIN, indev_act);
if(indev_reset_check(proc)) return;
lv_event_send(indev_obj_act, LV_EVENT_SCROLL_THROW_BEGIN, indev_act);
if(indev_reset_check(proc)) return;
}
proc->types.pointer.act_obj = NULL;
proc->pr_timestamp = 0;
proc->longpr_rep_timestamp = 0;

31
src/lv_core/lv_indev_scroll.c
View File

@@ -353,6 +353,37 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
}
}
/**
* Predict where would a scroll throw end
* @param indev pointer to an input device
* @param dir `LV_DIR_VER` or `LV_DIR_HOR`
* @return the difference compared to the current position when the throw would be finished
*/
lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir)
{
if(indev == NULL) return 0;
lv_coord_t v;
switch(dir) {
case LV_DIR_VER:
v = indev->proc.types.pointer.scroll_throw_vect.y;
break;
case LV_DIR_HOR:
v = indev->proc.types.pointer.scroll_throw_vect.x;
break;
default:
return 0;
}
lv_coord_t scroll_throw = indev->driver.scroll_throw;
lv_coord_t sum = 0;
while(v) {
sum += v;
v = v * (100 - scroll_throw) / 100;
}
return sum;
}
/**********************
* STATIC FUNCTIONS
**********************/

8
src/lv_core/lv_indev_scroll.h
View File

@@ -40,6 +40,14 @@ void _lv_scroll_handler(lv_indev_proc_t * proc);
*/
void _lv_scroll_throw_handler(lv_indev_proc_t * proc);
/**
* Predict where would a scroll throw end
* @param indev pointer to an input device
* @param dir `LV_DIR_VER` or `LV_DIR_HOR`
* @return the difference compared to the current position when the throw would be finished
*/
lv_coord_t _lv_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir);
/**********************
* MACROS
**********************/

2
src/lv_core/lv_obj.c
View File

@@ -1914,7 +1914,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
}
}
else if(sign == LV_SIGNAL_SCROLL) {
res = lv_event_send(obj, LV_EVENT_SCROLLED, NULL);
res = lv_event_send(obj, LV_EVENT_SCROLL, NULL);
if(res != LV_RES_OK) return res;
}
else if(sign == LV_SIGNAL_SCROLL_END) {

4
src/lv_core/lv_obj.h
View File

@@ -92,9 +92,8 @@ enum {
LV_EVENT_CLICKED, /**< Called on release if not scrolled (regardless to long press)*/
LV_EVENT_RELEASED, /**< Called in every cases when the object has been released*/
LV_EVENT_SCROLL_BEGIN,
LV_EVENT_SCROLL_THROW_BEGIN,
LV_EVENT_SCROLL_END,
LV_EVENT_SCROLLED,
LV_EVENT_SCROLL,
LV_EVENT_GESTURE, /**< The object has been gesture*/
LV_EVENT_KEY,
LV_EVENT_FOCUSED,
@@ -142,7 +141,6 @@ enum {
LV_SIGNAL_SCROLL_BEGIN, /**< The scrolling has just begun */
LV_SIGNAL_SCROLL, /**< The object has been scrolled */
LV_SIGNAL_SCROLL_END, /**< The scrolling has ended */
LV_SIGNAL_SCROLL_THROW_BEGIN,/**< Scroll throw started*/
LV_SIGNAL_GESTURE, /**< The object has been gesture*/
LV_SIGNAL_LEAVE, /**< Another object is clicked or chosen via an input device */

8
src/lv_core/lv_obj_pos.c
View File

@@ -98,7 +98,7 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_obj_set_pos(obj, x, lv_obj_get_y(obj));
lv_obj_set_pos(obj, x, obj->y_set);
}
/**
@@ -110,7 +110,7 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
lv_obj_set_pos(obj, obj->x_set, y);
}
/**
@@ -175,7 +175,7 @@ void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_obj_set_size(obj, w, lv_obj_get_height(obj));
lv_obj_set_size(obj, w, obj->h_set);
}
/**
@@ -187,7 +187,7 @@ void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_obj_set_size(obj, lv_obj_get_width(obj), h);
lv_obj_set_size(obj, obj->w_set, h);
}
/**

3
src/lv_core/lv_obj_scroll.c
View File

@@ -220,9 +220,6 @@ lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
*/
lv_coord_t lv_obj_get_scroll_right(const lv_obj_t * obj)
{
static uint32_t cnt = 0;
printf("scrl right: %d\n", cnt);
cnt++;
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_coord_t child_res = LV_COORD_MIN;

6
src/lv_misc/lv_anim.c
View File

@@ -260,7 +260,7 @@ lv_anim_value_t lv_anim_path_ease_in(const lv_anim_path_t * path, const lv_anim_
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = _lv_bezier3(t, 0, 100, 200, 1024);
int32_t step = _lv_bezier3(t, 0, 0, 1024 * 1 / 3, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -287,7 +287,7 @@ lv_anim_value_t lv_anim_path_ease_out(const lv_anim_path_t * path, const lv_anim
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = _lv_bezier3(t, 0, 800, 900, 1024);
int32_t step = _lv_bezier3(t, 0, 1024 * 2 / 3, 1024, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -314,7 +314,7 @@ lv_anim_value_t lv_anim_path_ease_in_out(const lv_anim_path_t * path, const lv_a
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = _lv_bezier3(t, 0, 100, 924, 1024);
int32_t step = _lv_bezier3(t, 0, 0, 1024, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);

401
src/lv_widgets/lv_roller.c
View File

@@ -13,6 +13,8 @@
#include "../lv_misc/lv_debug.h"
#include "../lv_draw/lv_draw.h"
#include "../lv_core/lv_group.h"
#include "../lv_core/lv_indev.h"
#include "../lv_core/lv_indev_scroll.h"
#include "../lv_themes/lv_theme.h"
/*********************
@@ -34,14 +36,11 @@
**********************/
static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode);
static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t * clip_area, lv_design_mode_t mode);
static lv_res_t lv_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void * param);
static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part);
static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param);
static void refr_position(lv_obj_t * roller, lv_anim_enable_t animen);
static void refr_height(lv_obj_t * roller);
static void refr_width(lv_obj_t * roller);
static lv_res_t release_handler(lv_obj_t * roller);
static void inf_normalize(void * roller_scrl);
static void inf_normalize(lv_obj_t * roller_scrl);
static lv_obj_t * get_label(const lv_obj_t * roller);
#if LV_USE_ANIMATION
static void scroll_anim_ready_cb(lv_anim_t * a);
@@ -52,8 +51,8 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area);
* STATIC VARIABLES
**********************/
static lv_signal_cb_t ancestor_signal;
static lv_design_cb_t ancestor_design;
static lv_design_cb_t ancestor_label_design;
static lv_signal_cb_t ancestor_scrl_signal;
/**********************
* MACROS
@@ -74,12 +73,12 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
LV_LOG_TRACE("roller create started");
/*Create the ancestor of roller*/
lv_obj_t * roller = lv_page_create(par, copy);
lv_obj_t * roller = lv_obj_create(par, copy);
LV_ASSERT_MEM(roller);
if(roller == NULL) return NULL;
if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_cb(lv_page_get_scrollable(roller));
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_cb(roller);
if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_cb(roller);
/*Allocate the roller type specific extended data*/
lv_roller_ext_t * ext = lv_obj_allocate_ext_attr(roller, sizeof(lv_roller_ext_t));
@@ -93,7 +92,6 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
ext->option_cnt = 0;
ext->sel_opt_id = 0;
ext->sel_opt_id_ori = 0;
ext->auto_fit = 1;
lv_style_list_init(&ext->style_sel);
/*The signal and design functions are not copied so set them here*/
@@ -102,22 +100,18 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
/*Init the new roller roller*/
if(copy == NULL) {
lv_obj_clear_flag(roller, LV_OBJ_FLAG_SCROLLABLE);
ext->anim_time = LV_ROLLER_DEF_ANIM_TIME;
lv_obj_set_width(roller, LV_SIZE_AUTO);
lv_obj_t * label = lv_label_create(roller, NULL);
lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
if(ancestor_label_design == NULL) ancestor_label_design = lv_obj_get_design_cb(label);
lv_obj_set_design_cb(label, lv_roller_label_design);
lv_obj_t * scrl = lv_page_get_scrollable(roller);
lv_obj_set_drag(scrl, true);
lv_page_set_scrollable_fit2(roller, LV_FIT_PARENT, LV_FIT_NONE); /*Height is specified directly*/
lv_roller_set_anim_time(roller, LV_ROLLER_DEF_ANIM_TIME);
lv_roller_set_options(roller, "Option 1\nOption 2\nOption 3\nOption 4\nOption 5", LV_ROLLER_MODE_NORMAL);
lv_obj_set_signal_cb(scrl, lv_roller_scrl_signal);
lv_obj_clean_style_list(roller, LV_PAGE_PART_SCROLLABLE); /*Use a transparent scrollable*/
lv_theme_apply(roller, LV_THEME_ROLLER);
refr_height(roller);
lv_roller_set_visible_row_count(roller, 3);
}
@@ -130,12 +124,9 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
ext->option_cnt = copy_ext->option_cnt;
ext->sel_opt_id = copy_ext->sel_opt_id;
ext->sel_opt_id_ori = copy_ext->sel_opt_id;
ext->auto_fit = copy_ext->auto_fit;
lv_obj_t * scrl = lv_page_get_scrollable(roller);
lv_obj_set_signal_cb(scrl, lv_roller_scrl_signal);
lv_style_list_copy(&ext->style_sel, &copy_ext->style_sel);
lv_obj_refresh_style(roller, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
_lv_obj_refresh_style(roller, LV_OBJ_PART_ALL, LV_STYLE_PROP_ALL);
}
LV_LOG_INFO("roller created");
@@ -194,12 +185,10 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
ext->sel_opt_id = ((LV_ROLLER_INF_PAGES / 2) + 0) * ext->option_cnt;
ext->option_cnt = ext->option_cnt * LV_ROLLER_INF_PAGES;
inf_normalize(roller);
}
ext->sel_opt_id_ori = ext->sel_opt_id;
refr_height(roller);
refr_width(roller);
}
/**
@@ -215,7 +204,6 @@ void lv_roller_set_align(lv_obj_t * roller, lv_label_align_t align)
if(label == NULL) return; /*Probably the roller is being deleted if the label is NULL.*/
lv_label_set_align(label, align);
refr_width(roller); /*To set the correct label position*/
}
/**
@@ -272,23 +260,19 @@ void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt)
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_obj_set_height(roller, (lv_font_get_line_height(font) + line_space) * row_cnt);
refr_height(roller);
refr_position(roller, LV_ANIM_OFF);
}
/**
* Allow automatically setting the width of roller according to it's content.
* Get the animation time of the roller
* @param roller pointer to a roller object
* @param auto_fit true: enable auto fit
* @param the animation time in milliseconds
*/
void lv_roller_set_auto_fit(lv_obj_t * roller, bool auto_fit)
void lv_roller_set_anim_time(lv_obj_t * roller, uint32_t anim_time)
{
LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
ext->auto_fit = auto_fit;
refr_width(roller);
ext->anim_time = anim_time;
}
/*=====================
* Getter functions
*====================*/
@@ -376,18 +360,6 @@ lv_label_align_t lv_roller_get_align(const lv_obj_t * roller)
return lv_label_get_align(get_label(roller));
}
/**
* Get whether the auto fit option is enabled or not.
* @param roller pointer to a roller object
* @return true: auto fit is enabled
*/
bool lv_roller_get_auto_fit(lv_obj_t * roller)
{
LV_ASSERT_OBJ(roller, LV_OBJX_NAME);
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
return ext->auto_fit ? true : false;
}
/**
* Get the options of a roller
* @param roller pointer to roller object
@@ -400,6 +372,16 @@ const char * lv_roller_get_options(const lv_obj_t * roller)
return lv_label_get_text(get_label(roller));
}
/**
* Get the animation time of the roller
* @param roller pointer to a roller object
* @return the animation time in milliseconds
*/
uint32_t lv_roller_get_anim_time(lv_obj_t * roller)
{
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
return ext->anim_time;
}
/**********************
* STATIC FUNCTIONS
@@ -418,22 +400,21 @@ const char * lv_roller_get_options(const lv_obj_t * roller)
static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
return LV_DESIGN_RES_NOT_COVER;
return ancestor_design(roller, clip_area, mode);
}
/*Draw the object*/
else if(mode == LV_DESIGN_DRAW_MAIN) {
draw_bg(roller, clip_area);
ancestor_design(roller, clip_area, mode);
/*Draw the selected rectangle*/
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
lv_area_t rect_area;
rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - line_space / 2;
if((font_h & 0x1) && (line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - font_h - line_space) / 2;
rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
lv_area_t roller_coords;
lv_obj_get_coords(roller, &roller_coords);
lv_obj_get_inner_coords(roller, &roller_coords);
rect_area.x1 = roller_coords.x1;
rect_area.x2 = roller_coords.x2;
@@ -453,8 +434,7 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
/*Redraw the text on the selected area*/
lv_area_t rect_area;
rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - bg_font_h / 2 - label_dsc.line_space / 2;
if((bg_font_h & 0x1) && (label_dsc.line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - bg_font_h - label_dsc.line_space) / 2;
rect_area.y2 = rect_area.y1 + bg_font_h + label_dsc.line_space - 1;
rect_area.x1 = roller->coords.x1;
rect_area.x2 = roller->coords.x2;
@@ -504,6 +484,8 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
label_dsc.flag |= LV_TXT_FLAG_EXPAND;
lv_draw_label(&label_sel_area, &mask_sel, &label_dsc, lv_label_get_text(label), NULL);
}
ancestor_design(roller, clip_area, mode);
}
return LV_DESIGN_RES_OK;
@@ -529,18 +511,17 @@ static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t
else if(mode == LV_DESIGN_DRAW_MAIN) {
/* Split the drawing of the label into an upper (above the selected area)
* and a lower (below the selected area)*/
lv_obj_t * roller = lv_obj_get_parent(lv_obj_get_parent(label));
lv_obj_t * roller = lv_obj_get_parent(label);
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
lv_area_t rect_area;
rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - line_space / 2;
rect_area.y1 = roller->coords.y1 + (lv_obj_get_height(roller) - font_h - line_space) / 2;
if((font_h & 0x1) && (line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
lv_area_t roller_coords;
lv_obj_get_coords(roller, &roller_coords);
lv_obj_get_inner_coords(roller, &roller_coords);
rect_area.x1 = roller_coords.x1;
rect_area.x2 = roller_coords.x2;
@@ -575,44 +556,55 @@ static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t
*/
static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param)
{
lv_res_t res = LV_RES_OK;
lv_res_t res;
/* Include the ancient signal function */
res = ancestor_signal(roller, sign, param);
if(res != LV_RES_OK) return res;
int32_t id = -1;
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
/* Include the ancient signal function */
if(sign == LV_SIGNAL_GET_STYLE) {
lv_get_style_info_t * info = param;
info->result = lv_roller_get_style(roller, info->part);
if(info->result != NULL) return LV_RES_OK;
else return ancestor_signal(roller, sign, param);
}
/* Include the ancient signal function */
if(sign != LV_SIGNAL_CONTROL) { /*Don't let the page to scroll on keys*/
res = ancestor_signal(roller, sign, param);
if(res != LV_RES_OK) return res;
else if(sign == LV_SIGNAL_GET_TYPE) {
return _lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
}
if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
LV_UNUSED(ext);
if(sign == LV_SIGNAL_STYLE_CHG) {
else if(sign == LV_SIGNAL_STYLE_CHG) {
lv_obj_t * label = get_label(roller);
/*Be sure the label's style is updated before processing the roller*/
if(label) lv_signal_send(label, LV_SIGNAL_STYLE_CHG, NULL);
refr_height(roller);
refr_width(roller);
refr_position(roller, false);
}
else if(sign == LV_SIGNAL_COORD_CHG) {
if(lv_obj_get_width(roller) != lv_area_get_width(param) ||
lv_obj_get_height(roller) != lv_area_get_height(param)) {
#if LV_USE_ANIMATION
lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
lv_obj_get_height(roller) != lv_area_get_height(param))
{
refr_position(roller, false);
refr_width(roller);
}
}
else if(sign == LV_SIGNAL_PRESSED) {
ext->moved = 0;
#if LV_USE_ANIMATION
lv_anim_del(get_label(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
}
else if(sign == LV_SIGNAL_PRESSING) {
lv_indev_t * indev = lv_indev_get_act();
lv_point_t p;
lv_indev_get_vect(indev, &p);
lv_obj_t * label = get_label(roller);
lv_obj_set_y(label, lv_obj_get_y(label) + p.y);
if(p.y) ext->moved = 1;
}
else if(sign == LV_SIGNAL_RELEASED) {
release_handler(roller);
}
@@ -672,8 +664,16 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
#endif
}
else if(sign == LV_SIGNAL_CLEANUP) {
lv_obj_clean_style_list(roller, LV_ROLLER_PART_SELECTED);
_lv_obj_reset_style_list_no_refr(roller, LV_ROLLER_PART_SELECTED);
}
/*Position the scrollable according to the new selected option*/
if(id != -1) {
refr_position(roller, LV_ANIM_ON);
}
return res;
}
@@ -704,77 +704,6 @@ static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part)
return style_dsc_p;
}
/**
* Signal function of the scrollable part of the roller.
* @param roller_scrl pointer to the scrollable part of roller (page)
* @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_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void * param)
{
lv_res_t res;
/* Include the ancient signal function */
res = ancestor_scrl_signal(roller_scrl, sign, param);
if(res != LV_RES_OK) return res;
if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
lv_obj_t * roller = lv_obj_get_parent(roller_scrl);
/*On delete the ddlist signal deletes the label so nothing left to do here*/
lv_obj_t * label = get_label(roller);
if(label == NULL) return LV_RES_INV;
int32_t id = -1;
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
if(sign == LV_SIGNAL_DRAG_END) {
/*If dragged then align the list to have an element in the middle*/
lv_coord_t label_y1 = label->coords.y1 - roller->coords.y1;
lv_coord_t label_unit = font_h + line_space;
lv_coord_t mid = (roller->coords.y2 - roller->coords.y1) / 2;
id = (mid - label_y1 + line_space / 2) / label_unit;
if(id < 0) id = 0;
if(id >= ext->option_cnt) id = ext->option_cnt - 1;
ext->sel_opt_id = id;
ext->sel_opt_id_ori = id;
res = lv_event_send(roller, LV_EVENT_VALUE_CHANGED, &id);
if(res != LV_RES_OK) return res;
}
/*If picked an option by clicking then set it*/
else if(sign == LV_SIGNAL_RELEASED) {
release_handler(roller);
}
else if(sign == LV_SIGNAL_PRESSED) {
#if LV_USE_ANIMATION
lv_anim_del(roller_scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
}
else if(sign == LV_SIGNAL_PARENT_SIZE_CHG) {
#if LV_USE_ANIMATION
lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
refr_position(roller, false);
refr_width(roller);
}
/*Position the scrollable according to the new selected option*/
if(id != -1) {
refr_position(roller, LV_ANIM_ON);
}
return res;
}
/**
* Draw a rectangle which has gradient on its top and bottom
* @param roller pointer to a roller object
@@ -793,7 +722,6 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area)
}
/*With vertical gradient mirror it*/
lv_area_t half_mask;
lv_coord_t h = lv_obj_get_height(roller);
bool union_ok;
@@ -837,45 +765,52 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area)
*/
static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
{
lv_obj_t * label = get_label(roller);
if(label == NULL) return;
#if LV_USE_ANIMATION == 0
anim_en = LV_ANIM_OFF;
#endif
lv_obj_t * roller_scrl = lv_page_get_scrollable(roller);
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
lv_coord_t h = lv_obj_get_height(roller);
lv_coord_t h = lv_obj_get_height_fit(roller);
uint16_t anim_time = lv_roller_get_anim_time(roller);
/* Normally the animation's `end_cb` sets correct position of the roller if infinite.
* But without animations do it manually*/
if(anim_en == LV_ANIM_OFF || anim_time == 0) {
inf_normalize(roller_scrl);
inf_normalize(roller);
}
lv_obj_t * label = get_label(roller);
int32_t id = ext->sel_opt_id;
lv_coord_t line_y1 = id * (font_h + line_space) + label->coords.y1 - roller_scrl->coords.y1;
lv_coord_t new_y = -line_y1 + (h - font_h) / 2;
lv_coord_t sel_y1 = id * (font_h + line_space);
lv_coord_t mid_y1 = h / 2 - font_h / 2;
lv_coord_t new_y = mid_y1 - sel_y1;
if(anim_en == LV_ANIM_OFF || anim_time == 0) {
#if LV_USE_ANIMATION
lv_anim_del(roller_scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
lv_anim_del(label, (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
lv_obj_set_y(roller_scrl, new_y);
lv_obj_set_y(label, new_y);
}
else {
#if LV_USE_ANIMATION
lv_anim_path_t path;
lv_anim_path_init(&path);
lv_anim_path_set_cb(&path, lv_anim_path_ease_out);
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, roller_scrl);
lv_anim_set_var(&a, label);
lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_obj_set_y);
lv_anim_set_values(&a, lv_obj_get_y(roller_scrl), new_y);
lv_anim_set_values(&a, lv_obj_get_y(label), new_y);
lv_anim_set_time(&a, anim_time);
lv_anim_set_ready_cb(&a, scroll_anim_ready_cb);
lv_anim_set_path(&a, &path);
lv_anim_start(&a);
#endif
}
@@ -885,12 +820,12 @@ static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
static lv_res_t release_handler(lv_obj_t * roller)
{
/*If there was dragging `DRAG_END` signal will refresh the position and update the selected option*/
if(lv_indev_is_scrolling(lv_indev_get_act())) return LV_RES_OK;
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
lv_obj_t * label = get_label(roller);
if(label == NULL) return LV_RES_OK;
lv_indev_t * indev = lv_indev_get_act();
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
#if LV_USE_GROUP
/*Leave edit mode once a new option is selected*/
lv_indev_type_t indev_type = lv_indev_get_type(indev);
@@ -906,32 +841,50 @@ static lv_res_t release_handler(lv_obj_t * roller)
}
#endif
lv_obj_t * label = get_label(roller);
if(label == NULL) return LV_RES_OK;
if(lv_indev_get_type(indev) == LV_INDEV_TYPE_POINTER || lv_indev_get_type(indev) == LV_INDEV_TYPE_BUTTON) {
/*Search the clicked option (For KEYPAD and ENCODER the new value should be already set)*/
uint16_t new_opt = 0;
lv_point_t p;
lv_indev_get_point(indev, &p);
p.y -= label->coords.y1;
p.x -= label->coords.x1;
uint32_t letter_i;
letter_i = lv_label_get_letter_on(label, &p);
int16_t new_opt = -1;
if(ext->moved == 0) {
new_opt = 0;
lv_point_t p;
lv_indev_get_point(indev, &p);
p.y -= label->coords.y1;
p.x -= label->coords.x1;
uint32_t letter_i;
letter_i = lv_label_get_letter_on(label, &p);
const char * txt = lv_label_get_text(label);
uint32_t i = 0;
uint32_t i_prev = 0;
const char * txt = lv_label_get_text(label);
uint32_t i = 0;
uint32_t i_prev = 0;
uint32_t letter_cnt = 0;
for(letter_cnt = 0; letter_cnt < letter_i; letter_cnt++) {
uint32_t letter = _lv_txt_encoded_next(txt, &i);
/*Count he lines to reach the clicked letter. But ignore the last '\n' because it
* still belongs to the clicked line*/
if(letter == '\n' && i_prev != letter_i) new_opt++;
i_prev = i;
uint32_t letter_cnt = 0;
for(letter_cnt = 0; letter_cnt < letter_i; letter_cnt++) {
uint32_t letter = _lv_txt_encoded_next(txt, &i);
/*Count he lines to reach the clicked letter. But ignore the last '\n' because it
* still belongs to the clicked line*/
if(letter == '\n' && i_prev != letter_i) new_opt++;
i_prev = i;
}
} else {
/*If dragged then align the list to have an element in the middle*/
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
lv_coord_t label_unit = font_h + line_space;
lv_coord_t mid = roller->coords.y1 + (roller->coords.y2 - roller->coords.y1) / 2;
lv_coord_t label_y1 = label->coords.y1 + _lv_scroll_throw_predict(indev, LV_DIR_VER);
int32_t id = (mid - label_y1) / label_unit;
if(id < 0) id = 0;
if(id >= ext->option_cnt) id = ext->option_cnt - 1;
new_opt = id;
}
if(new_opt >= 0) {
lv_roller_set_selected(roller, new_opt, LV_ANIM_ON);
}
lv_roller_set_selected(roller, new_opt, LV_ANIM_ON);
}
uint32_t id = ext->sel_opt_id; /*Just to use uint32_t in event data*/
@@ -939,71 +892,12 @@ static lv_res_t release_handler(lv_obj_t * roller)
return res;
}
static void refr_width(lv_obj_t * roller)
{
lv_obj_t * label = get_label(roller);
if(label == NULL) return;
switch(lv_label_get_align(label)) {
case LV_LABEL_ALIGN_LEFT:
lv_obj_align(label, NULL, LV_ALIGN_IN_LEFT_MID, 0, 0);
break;
case LV_LABEL_ALIGN_CENTER:
lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0);
break;
case LV_LABEL_ALIGN_RIGHT:
lv_obj_align(label, NULL, LV_ALIGN_IN_RIGHT_MID, 0, 0);
break;
}
if(lv_roller_get_auto_fit(roller) == false) return;
lv_coord_t label_w = lv_obj_get_width(label);
lv_style_int_t left = lv_obj_get_style_pad_left(roller, LV_ROLLER_PART_BG);
lv_style_int_t right = lv_obj_get_style_pad_right(roller, LV_ROLLER_PART_BG);
const lv_font_t * base_font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
const lv_font_t * sel_font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_SELECTED);
/*The selected text might be larger to get its size*/
if(base_font != sel_font) {
lv_coord_t letter_sp = lv_obj_get_style_text_letter_space(roller, LV_ROLLER_PART_SELECTED);
lv_coord_t line_sp = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_SELECTED);
lv_point_t p;
_lv_txt_get_size(&p, lv_label_get_text(label), sel_font, letter_sp, line_sp, LV_COORD_MAX, LV_TXT_FLAG_NONE);
if(label_w < p.x)label_w = p.x;
}
lv_obj_set_width(roller, label_w + left + right);
}
/**
* Refresh the height of the roller and the scrollable
* @param roller pointer to roller
*/
static void refr_height(lv_obj_t * roller)
{
lv_obj_t * label = get_label(roller);
if(label == NULL) return;
lv_obj_set_height(lv_page_get_scrollable(roller), lv_obj_get_height(label) + lv_obj_get_height(roller));
#if LV_USE_ANIMATION
lv_anim_del(lv_page_get_scrollable(roller), (lv_anim_exec_xcb_t)lv_obj_set_y);
#endif
refr_position(roller, LV_ANIM_OFF);
}
/**
* Set the middle page for the roller if infinite is enabled
* @param scrl pointer to the roller's scrollable (lv_obj_t *)
* @param roller pointer to a roller object
*/
static void inf_normalize(void * scrl)
static void inf_normalize(lv_obj_t * roller)
{
lv_obj_t * roller_scrl = (lv_obj_t *)scrl;
lv_obj_t * roller = lv_obj_get_parent(roller_scrl);
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
@@ -1018,27 +912,28 @@ static void inf_normalize(void * scrl)
const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
lv_coord_t font_h = lv_font_get_line_height(font);
lv_coord_t h = lv_obj_get_height(roller);
lv_coord_t h = lv_obj_get_height_fit(roller);
lv_obj_t * label = get_label(roller);
lv_coord_t line_y1 = ext->sel_opt_id * (font_h + line_space) + label->coords.y1 - roller_scrl->coords.y1;
lv_coord_t new_y = -line_y1 + (h - font_h) / 2;
lv_obj_set_y(roller_scrl, new_y);
lv_coord_t sel_y1 = ext->sel_opt_id * (font_h + line_space);
lv_coord_t mid_y1 = h / 2 - font_h / 2;
lv_coord_t new_y = mid_y1 - sel_y1;
lv_obj_set_y(label, new_y);
}
}
static lv_obj_t * get_label(const lv_obj_t * roller)
{
lv_obj_t * scrl = lv_page_get_scrollable(roller);
if(scrl == NULL) return NULL; /*The roller is being deleted, the scrollable already not exists*/
return lv_obj_get_child(scrl, NULL);
return lv_obj_get_child(roller, NULL);
}
#if LV_USE_ANIMATION
static void scroll_anim_ready_cb(lv_anim_t * a)
{
inf_normalize(a->var);
lv_obj_t * roller = lv_obj_get_parent(a->var); /*The label is animated*/
inf_normalize(roller);
}
#endif

47
src/lv_widgets/lv_roller.h
View File

@@ -17,13 +17,7 @@ extern "C" {
#if LV_USE_ROLLER != 0
/*Testing of dependencies*/
#if LV_USE_PAGE == 0
#error "lv_roller: lv_page is required. Enable it in lv_conf.h (LV_USE_PAGE 1) "
#endif
#include "../lv_core/lv_obj.h"
#include "lv_page.h"
#include "lv_label.h"
/*********************
@@ -46,20 +40,21 @@ typedef uint8_t lv_roller_mode_t;
/*Data of roller*/
typedef struct {
lv_page_ext_t page; /*Ext. of ancestor*/
/*No inherited ext.*/ /*Ext. of ancestor*/
/*New data for this type */
lv_style_list_t style_sel; /*Style of the selected option*/
uint16_t option_cnt; /*Number of options*/
uint16_t sel_opt_id; /*Index of the current option*/
uint16_t sel_opt_id_ori; /*Store the original index on focus*/
uint32_t anim_time;
lv_roller_mode_t mode : 1;
uint8_t auto_fit : 1; /*1: Automatically set the width*/
uint32_t moved : 1;
} lv_roller_ext_t;
enum {
LV_ROLLER_PART_BG = LV_PAGE_PART_BG,
LV_ROLLER_PART_SELECTED = _LV_PAGE_PART_VIRTUAL_LAST,
LV_ROLLER_PART_BG = LV_OBJ_PART_MAIN,
LV_ROLLER_PART_SELECTED,
_LV_ROLLER_PART_VIRTUAL_LAST,
};
typedef uint8_t lv_roller_part_t;
@@ -111,21 +106,11 @@ void lv_roller_set_selected(lv_obj_t * roller, uint16_t sel_opt, lv_anim_enable_
void lv_roller_set_visible_row_count(lv_obj_t * roller, uint8_t row_cnt);
/**
* Allow automatically setting the width of roller according to it's content.
* Get the animation time of the roller
* @param roller pointer to a roller object
* @param auto_fit true: enable auto fit
* @param the animation time in milliseconds
*/
void lv_roller_set_auto_fit(lv_obj_t * roller, bool auto_fit);
/**
* Set the open/close animation time.
* @param roller pointer to a roller object
* @param anim_time: open/close animation time [ms]
*/
static inline void lv_roller_set_anim_time(lv_obj_t * roller, uint16_t anim_time)
{
lv_page_set_anim_time(roller, anim_time);
}
void lv_roller_set_anim_time(lv_obj_t * roller, uint32_t anim_time);
/*=====================
* Getter functions
@@ -159,13 +144,6 @@ void lv_roller_get_selected_str(const lv_obj_t * roller, char * buf, uint32_t bu
*/
lv_label_align_t lv_roller_get_align(const lv_obj_t * roller);
/**
* Get whether the auto fit option is enabled or not.
* @param roller pointer to a roller object
* @return true: auto fit is enabled
*/
bool lv_roller_get_auto_fit(lv_obj_t * roller);
/**
* Get the options of a roller
* @param roller pointer to roller object
@@ -173,15 +151,6 @@ bool lv_roller_get_auto_fit(lv_obj_t * roller);
*/
const char * lv_roller_get_options(const lv_obj_t * roller);
/**
* Get the open/close animation time.
* @param roller pointer to a roller
* @return open/close animation time [ms]
*/
static inline uint16_t lv_roller_get_anim_time(const lv_obj_t * roller)
{
return lv_page_get_anim_time(roller);
}
/**********************