mirror of https://github.com/arendst/Tasmota.git
ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change) (#20183)
* ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change) * merge * parse * finalize
This commit is contained in:
s-hadinger
GitHub
parent
79de12decc
commit
ddb11779fd
|
|
@ -11,6 +11,7 @@ All notable changes to this project will be documented in this file.
|
|||
### Breaking Changed
|
||||
|
||||
### Changed
|
||||
- ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change)
|
||||
|
||||
### Fixed
|
||||
|
||||
|
|
|
|||
|
|
@ -968,12 +968,14 @@ const be_ntv_func_def_t lv_switch_func[] = {
|
|||
const be_ntv_func_def_t lv_table_func[] = {
|
||||
{ "add_cell_ctrl", { (const void*) &lv_table_add_cell_ctrl, "", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
|
||||
{ "clear_cell_ctrl", { (const void*) &lv_table_clear_cell_ctrl, "", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
|
||||
{ "get_cell_user_data", { (const void*) &lv_table_get_cell_user_data, ".", "(lv.lv_obj)ii" } },
|
||||
{ "get_cell_value", { (const void*) &lv_table_get_cell_value, "s", "(lv.lv_obj)ii" } },
|
||||
{ "get_col_cnt", { (const void*) &lv_table_get_col_cnt, "i", "(lv.lv_obj)" } },
|
||||
{ "get_col_width", { (const void*) &lv_table_get_col_width, "i", "(lv.lv_obj)i" } },
|
||||
{ "get_row_cnt", { (const void*) &lv_table_get_row_cnt, "i", "(lv.lv_obj)" } },
|
||||
{ "get_selected_cell", { (const void*) &lv_table_get_selected_cell, "", "(lv.lv_obj)(lv.uint16)(lv.uint16)" } },
|
||||
{ "has_cell_ctrl", { (const void*) &lv_table_has_cell_ctrl, "b", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
|
||||
{ "set_cell_user_data", { (const void*) &lv_table_set_cell_user_data, "", "(lv.lv_obj)ii." } },
|
||||
{ "set_cell_value", { (const void*) &lv_table_set_cell_value, "", "(lv.lv_obj)iis" } },
|
||||
{ "set_cell_value_fmt", { (const void*) &lv_table_set_cell_value_fmt, "", "(lv.lv_obj)iis[......]" } },
|
||||
{ "set_col_cnt", { (const void*) &lv_table_set_col_cnt, "", "(lv.lv_obj)i" } },
|
||||
|
|
|
|||
|
|
@ -907,12 +907,14 @@ extern int lvbe_table_set_col_cnt(bvm *vm);
|
|||
extern int lvbe_table_set_col_width(bvm *vm);
|
||||
extern int lvbe_table_add_cell_ctrl(bvm *vm);
|
||||
extern int lvbe_table_clear_cell_ctrl(bvm *vm);
|
||||
extern int lvbe_table_set_cell_user_data(bvm *vm);
|
||||
extern int lvbe_table_get_cell_value(bvm *vm);
|
||||
extern int lvbe_table_get_row_cnt(bvm *vm);
|
||||
extern int lvbe_table_get_col_cnt(bvm *vm);
|
||||
extern int lvbe_table_get_col_width(bvm *vm);
|
||||
extern int lvbe_table_has_cell_ctrl(bvm *vm);
|
||||
extern int lvbe_table_get_selected_cell(bvm *vm);
|
||||
extern int lvbe_table_get_cell_user_data(bvm *vm);
|
||||
|
||||
/* `lv_textarea` external functions definitions */
|
||||
extern int lvbe_textarea_create(bvm *vm);
|
||||
|
|
|
|||
|
|
@ -1130,12 +1130,14 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
|
|||
void lv_table_set_col_width(lv_obj_t * obj, uint16_t col_id, lv_coord_t w)
|
||||
void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
|
||||
void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
|
||||
void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data)
|
||||
const char * lv_table_get_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col)
|
||||
uint16_t lv_table_get_row_cnt(lv_obj_t * obj)
|
||||
uint16_t lv_table_get_col_cnt(lv_obj_t * obj)
|
||||
lv_coord_t lv_table_get_col_width(lv_obj_t * obj, uint16_t col)
|
||||
bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
|
||||
void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
|
||||
void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col)
|
||||
|
||||
// ../../lvgl/src/widgets/lv_textarea.h
|
||||
lv_obj_t * lv_textarea_create(lv_obj_t * parent)
|
||||
|
|
|
|||
|
|
@ -432,11 +432,10 @@ const be_ctypes_structure_t be_lv_draw_mask_saved = {
|
|||
|
||||
const be_ctypes_structure_t be_lv_meter_scale = {
|
||||
36, /* size in bytes */
|
||||
15, /* number of elements */
|
||||
14, /* number of elements */
|
||||
be_ctypes_instance_mappings,
|
||||
(const be_ctypes_structure_item_t[15]) {
|
||||
(const be_ctypes_structure_item_t[14]) {
|
||||
{ "angle_range", 30, 0, 0, ctypes_u16, 0 },
|
||||
{ "label_color", 18, 0, 0, ctypes_i16, 0 },
|
||||
{ "label_gap", 16, 0, 0, ctypes_i16, 0 },
|
||||
{ "max", 24, 0, 0, ctypes_i32, 0 },
|
||||
{ "min", 20, 0, 0, ctypes_i32, 0 },
|
||||
|
|
|
|||
|
|
@ -353,7 +353,6 @@ lv_meter_scale = [ # valid LVGL8.3
|
|||
[uint16_t, "tick_major_width"],
|
||||
|
||||
[int16_t, "label_gap"],
|
||||
[int16_t, "label_color"],
|
||||
|
||||
[int32_t, "min"],
|
||||
[int32_t, "max"],
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "lvgl",
|
||||
"version": "8.3.10",
|
||||
"version": "8.3.11",
|
||||
"keywords": "graphics, gui, embedded, tft, lvgl",
|
||||
"description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.",
|
||||
"repository": {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
name=lvgl
|
||||
version=8.3.10
|
||||
version=8.3.11
|
||||
author=kisvegabor
|
||||
maintainer=kisvegabor,embeddedt,pete-pjb
|
||||
sentence=Full-featured Graphics Library for Embedded Systems
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
* @file lv_conf.h
|
||||
* Configuration file for v8.3.9
|
||||
* Configuration file for v8.3.11
|
||||
*/
|
||||
|
||||
/*
|
||||
|
|
@ -639,6 +639,13 @@
|
|||
#define LV_FS_FATFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
|
||||
#endif
|
||||
|
||||
/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/
|
||||
#define LV_USE_FS_LITTLEFS 0
|
||||
#if LV_USE_FS_LITTLEFS
|
||||
#define LV_FS_LITTLEFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
|
||||
#define LV_FS_LITTLEFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
|
||||
#endif
|
||||
|
||||
/*PNG decoder library*/
|
||||
#define LV_USE_PNG 0
|
||||
|
||||
|
|
@ -672,6 +679,13 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
/*Tiny TTF library*/
|
||||
#define LV_USE_TINY_TTF 0
|
||||
#if LV_USE_TINY_TTF
|
||||
/*Load TTF data from files*/
|
||||
#define LV_TINY_TTF_FILE_SUPPORT 0
|
||||
#endif
|
||||
|
||||
/*Rlottie library*/
|
||||
#define LV_USE_RLOTTIE 0
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ extern "C" {
|
|||
***************************/
|
||||
#define LVGL_VERSION_MAJOR 8
|
||||
#define LVGL_VERSION_MINOR 3
|
||||
#define LVGL_VERSION_PATCH 10
|
||||
#define LVGL_VERSION_PATCH 11
|
||||
#define LVGL_VERSION_INFO ""
|
||||
|
||||
/*********************
|
||||
|
|
|
|||
|
|
@ -224,9 +224,13 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
|
|||
lv_disp_t * d = lv_obj_get_disp(new_scr);
|
||||
lv_obj_t * act_scr = lv_scr_act();
|
||||
|
||||
if(act_scr == new_scr || d->scr_to_load == new_scr) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*If an other screen load animation is in progress
|
||||
*make target screen loaded immediately. */
|
||||
if(d->scr_to_load && act_scr != d->scr_to_load) {
|
||||
if(d->scr_to_load) {
|
||||
scr_load_internal(d->scr_to_load);
|
||||
lv_anim_del(d->scr_to_load, NULL);
|
||||
lv_obj_set_pos(d->scr_to_load, 0, 0);
|
||||
|
|
@ -258,7 +262,6 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
|
|||
lv_obj_remove_local_style_prop(new_scr, LV_STYLE_OPA, 0);
|
||||
lv_obj_remove_local_style_prop(lv_scr_act(), LV_STYLE_OPA, 0);
|
||||
|
||||
|
||||
/*Shortcut for immediate load*/
|
||||
if(time == 0 && delay == 0) {
|
||||
scr_load_internal(new_scr);
|
||||
|
|
@ -478,6 +481,7 @@ static void scr_load_internal(lv_obj_t * scr)
|
|||
if(d->act_scr) lv_event_send(scr, LV_EVENT_SCREEN_LOAD_START, NULL);
|
||||
|
||||
d->act_scr = scr;
|
||||
d->scr_to_load = NULL;
|
||||
|
||||
if(d->act_scr) lv_event_send(scr, LV_EVENT_SCREEN_LOADED, NULL);
|
||||
if(d->act_scr) lv_event_send(old_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
|
||||
|
|
|
|||
|
|
@ -149,9 +149,9 @@ void lv_init(void)
|
|||
lv_img_cache_set_size(LV_IMG_CACHE_DEF_SIZE);
|
||||
#endif
|
||||
/*Test if the IDE has UTF-8 encoding*/
|
||||
char * txt = "Á";
|
||||
const char * txt = "Á";
|
||||
|
||||
uint8_t * txt_u8 = (uint8_t *)txt;
|
||||
const uint8_t * txt_u8 = (uint8_t *)txt;
|
||||
if(txt_u8[0] != 0xc3 || txt_u8[1] != 0x81 || txt_u8[2] != 0x00) {
|
||||
LV_LOG_WARN("The strings have no UTF-8 encoding. Non-ASCII characters won't be displayed.");
|
||||
}
|
||||
|
|
@ -862,6 +862,10 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
|
|||
lv_obj_mark_layout_as_dirty(obj);
|
||||
}
|
||||
}
|
||||
else if(code == LV_EVENT_CHILD_DELETED) {
|
||||
obj->readjust_scroll_after_layout = 1;
|
||||
lv_obj_mark_layout_as_dirty(obj);
|
||||
}
|
||||
else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
|
||||
lv_coord_t d = lv_obj_calculate_ext_draw_size(obj, LV_PART_MAIN);
|
||||
lv_event_set_ext_draw_size(e, d);
|
||||
|
|
|
|||
|
|
@ -183,6 +183,7 @@ typedef struct _lv_obj_t {
|
|||
lv_obj_flag_t flags;
|
||||
lv_state_t state;
|
||||
uint16_t layout_inv : 1;
|
||||
uint16_t readjust_scroll_after_layout : 1;
|
||||
uint16_t scr_layout_inv : 1;
|
||||
uint16_t skip_trans : 1;
|
||||
uint16_t style_cnt : 6;
|
||||
|
|
|
|||
|
|
@ -179,12 +179,11 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
|
|||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if(opa < LV_OPA_MAX) {
|
||||
draw_dsc->bg_opa = (opa * draw_dsc->shadow_opa) >> 8;
|
||||
draw_dsc->bg_img_opa = (opa * draw_dsc->shadow_opa) >> 8;
|
||||
draw_dsc->border_opa = (opa * draw_dsc->shadow_opa) >> 8;
|
||||
draw_dsc->outline_opa = (opa * draw_dsc->shadow_opa) >> 8;
|
||||
draw_dsc->bg_opa = (opa * draw_dsc->bg_opa) >> 8;
|
||||
draw_dsc->bg_img_opa = (opa * draw_dsc->bg_img_opa) >> 8;
|
||||
draw_dsc->border_opa = (opa * draw_dsc->border_opa) >> 8;
|
||||
draw_dsc->outline_opa = (opa * draw_dsc->outline_opa) >> 8;
|
||||
draw_dsc->shadow_opa = (opa * draw_dsc->shadow_opa) >> 8;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -200,7 +200,7 @@ bool lv_obj_refr_size(lv_obj_t * obj)
|
|||
/*Invalidate the new area*/
|
||||
lv_obj_invalidate(obj);
|
||||
|
||||
lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
|
||||
obj->readjust_scroll_after_layout = 1;
|
||||
|
||||
/*If the object was out of the parent invalidate the new scrollbar area too.
|
||||
*If it wasn't out of the parent but out now, also invalidate the scrollbars*/
|
||||
|
|
@ -1137,20 +1137,24 @@ static void layout_update_core(lv_obj_t * obj)
|
|||
layout_update_core(child);
|
||||
}
|
||||
|
||||
if(obj->layout_inv == 0) return;
|
||||
if(obj->layout_inv) {
|
||||
obj->layout_inv = 0;
|
||||
lv_obj_refr_size(obj);
|
||||
lv_obj_refr_pos(obj);
|
||||
|
||||
obj->layout_inv = 0;
|
||||
|
||||
lv_obj_refr_size(obj);
|
||||
lv_obj_refr_pos(obj);
|
||||
|
||||
if(child_cnt > 0) {
|
||||
uint32_t layout_id = lv_obj_get_style_layout(obj, LV_PART_MAIN);
|
||||
if(layout_id > 0 && layout_id <= layout_cnt) {
|
||||
void * user_data = LV_GC_ROOT(_lv_layout_list)[layout_id - 1].user_data;
|
||||
LV_GC_ROOT(_lv_layout_list)[layout_id - 1].cb(obj, user_data);
|
||||
if(child_cnt > 0) {
|
||||
uint32_t layout_id = lv_obj_get_style_layout(obj, LV_PART_MAIN);
|
||||
if(layout_id > 0 && layout_id <= layout_cnt) {
|
||||
void * user_data = LV_GC_ROOT(_lv_layout_list)[layout_id - 1].user_data;
|
||||
LV_GC_ROOT(_lv_layout_list)[layout_id - 1].cb(obj, user_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(obj->readjust_scroll_after_layout) {
|
||||
obj->readjust_scroll_after_layout = 0;
|
||||
lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
|
||||
}
|
||||
}
|
||||
|
||||
static void transform_point(const lv_obj_t * obj, lv_point_t * p, bool inv)
|
||||
|
|
|
|||
|
|
@ -290,7 +290,7 @@ void lv_obj_get_scrollbar_area(struct _lv_obj_t * obj, lv_area_t * hor, lv_area_
|
|||
void lv_obj_scrollbar_invalidate(struct _lv_obj_t * obj);
|
||||
|
||||
/**
|
||||
* Checked if the content is scrolled "in" and adjusts it to a normal position.
|
||||
* Checks if the content is scrolled "in" and adjusts it to a normal position.
|
||||
* @param obj pointer to an object
|
||||
* @param anim_en LV_ANIM_ON/OFF
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -608,8 +608,7 @@ void lv_obj_set_style_opa_layered(struct _lv_obj_t * obj, lv_opa_t value, lv_sty
|
|||
lv_obj_set_local_style_prop(obj, LV_STYLE_OPA_LAYERED, v, selector);
|
||||
}
|
||||
|
||||
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
|
||||
lv_style_selector_t selector)
|
||||
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector)
|
||||
{
|
||||
lv_style_value_t v = {
|
||||
.ptr = value
|
||||
|
|
@ -649,8 +648,7 @@ void lv_obj_set_style_anim_speed(struct _lv_obj_t * obj, uint32_t value, lv_styl
|
|||
lv_obj_set_local_style_prop(obj, LV_STYLE_ANIM_SPEED, v, selector);
|
||||
}
|
||||
|
||||
void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value,
|
||||
lv_style_selector_t selector)
|
||||
void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector)
|
||||
{
|
||||
lv_style_value_t v = {
|
||||
.ptr = value
|
||||
|
|
|
|||
|
|
@ -162,8 +162,7 @@ static inline lv_color_t lv_obj_get_style_bg_grad_color(const struct _lv_obj_t *
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_bg_grad_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_BG_GRAD_COLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_COLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -217,8 +216,7 @@ static inline lv_color_t lv_obj_get_style_bg_img_recolor(const struct _lv_obj_t
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_bg_img_recolor_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_BG_IMG_RECOLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMG_RECOLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -242,8 +240,7 @@ static inline lv_color_t lv_obj_get_style_border_color(const struct _lv_obj_t *
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_border_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_BORDER_COLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_COLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -285,8 +282,7 @@ static inline lv_color_t lv_obj_get_style_outline_color(const struct _lv_obj_t *
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_outline_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_OUTLINE_COLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_COLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -334,8 +330,7 @@ static inline lv_color_t lv_obj_get_style_shadow_color(const struct _lv_obj_t *
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_shadow_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_SHADOW_COLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_COLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -359,8 +354,7 @@ static inline lv_color_t lv_obj_get_style_img_recolor(const struct _lv_obj_t * o
|
|||
|
||||
static inline lv_color_t lv_obj_get_style_img_recolor_filtered(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
|
||||
LV_STYLE_IMG_RECOLOR));
|
||||
lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_IMG_RECOLOR));
|
||||
return v.color;
|
||||
}
|
||||
|
||||
|
|
@ -520,8 +514,7 @@ static inline lv_opa_t lv_obj_get_style_opa_layered(const struct _lv_obj_t * obj
|
|||
return (lv_opa_t)v.num;
|
||||
}
|
||||
|
||||
static inline const lv_color_filter_dsc_t * lv_obj_get_style_color_filter_dsc(const struct _lv_obj_t * obj,
|
||||
uint32_t part)
|
||||
static inline const lv_color_filter_dsc_t * lv_obj_get_style_color_filter_dsc(const struct _lv_obj_t * obj, uint32_t part)
|
||||
{
|
||||
lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_COLOR_FILTER_DSC);
|
||||
return (const lv_color_filter_dsc_t *)v.ptr;
|
||||
|
|
@ -651,14 +644,12 @@ void lv_obj_set_style_radius(struct _lv_obj_t * obj, lv_coord_t value, lv_style_
|
|||
void lv_obj_set_style_clip_corner(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_opa_layered(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
|
||||
lv_style_selector_t selector);
|
||||
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_color_filter_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_anim(struct _lv_obj_t * obj, const lv_anim_t * value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_anim_time(struct _lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_anim_speed(struct _lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value,
|
||||
lv_style_selector_t selector);
|
||||
void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_blend_mode(struct _lv_obj_t * obj, lv_blend_mode_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_layout(struct _lv_obj_t * obj, uint16_t value, lv_style_selector_t selector);
|
||||
void lv_obj_set_style_base_dir(struct _lv_obj_t * obj, lv_base_dir_t value, lv_style_selector_t selector);
|
||||
|
|
|
|||
|
|
@ -49,9 +49,6 @@ void lv_obj_del(lv_obj_t * obj)
|
|||
lv_obj_invalidate(obj);
|
||||
|
||||
lv_obj_t * par = lv_obj_get_parent(obj);
|
||||
if(par) {
|
||||
lv_obj_scrollbar_invalidate(par);
|
||||
}
|
||||
|
||||
lv_disp_t * disp = NULL;
|
||||
bool act_scr_del = false;
|
||||
|
|
@ -65,8 +62,6 @@ void lv_obj_del(lv_obj_t * obj)
|
|||
|
||||
/*Call the ancestor's event handler to the parent to notify it about the child delete*/
|
||||
if(par) {
|
||||
lv_obj_update_layout(par);
|
||||
lv_obj_readjust_scroll(par, LV_ANIM_OFF);
|
||||
lv_obj_scrollbar_invalidate(par);
|
||||
lv_event_send(par, LV_EVENT_CHILD_CHANGED, NULL);
|
||||
lv_event_send(par, LV_EVENT_CHILD_DELETED, NULL);
|
||||
|
|
@ -173,7 +168,6 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
|
|||
obj->parent = parent;
|
||||
|
||||
/*Notify the original parent because one of its children is lost*/
|
||||
lv_obj_readjust_scroll(old_parent, LV_ANIM_OFF);
|
||||
lv_obj_scrollbar_invalidate(old_parent);
|
||||
lv_event_send(old_parent, LV_EVENT_CHILD_CHANGED, obj);
|
||||
lv_event_send(old_parent, LV_EVENT_CHILD_DELETED, NULL);
|
||||
|
|
|
|||
|
|
@ -34,6 +34,19 @@
|
|||
#error "Cannot use DMA2D with LV_COLOR_DEPTH other than 16 or 32"
|
||||
#endif
|
||||
|
||||
#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
|
||||
#define LV_STM32_DMA2D_USE_M7_CACHE
|
||||
#endif
|
||||
|
||||
#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
|
||||
// Cortex-M7 DCache present
|
||||
#define __lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size) _lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size)
|
||||
#define __lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size) _lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size)
|
||||
#else
|
||||
#define __lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size)
|
||||
#define __lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size)
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
|
|
@ -61,13 +74,19 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_copy_buffer(const lv_color_t * d
|
|||
const lv_area_t * draw_area, const lv_color_t * src_buf, lv_coord_t src_stride, const lv_point_t * src_offset);
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_await_dma_transfer_finish(lv_disp_drv_t * disp_drv);
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_start_dma_transfer(void);
|
||||
|
||||
#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address, lv_coord_t offset,
|
||||
lv_coord_t width, lv_coord_t height, uint8_t pixel_size);
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
|
||||
lv_coord_t height, uint8_t pixel_size);
|
||||
LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void);
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void);
|
||||
LV_STM32_DMA2D_STATIC uint32_t _lv_gpu_stm32_dwt_get_us(void);
|
||||
#endif
|
||||
|
||||
#if defined(LV_STM32_DMA2D_TEST)
|
||||
LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void);
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void);
|
||||
LV_STM32_DMA2D_STATIC uint32_t _lv_gpu_stm32_dwt_get_us(void);
|
||||
#endif
|
||||
|
||||
static bool isDma2dInProgess = false; // indicates whether DMA2D transfer *initiated here* is in progress
|
||||
|
||||
|
|
@ -77,21 +96,21 @@ static bool isDma2dInProgess = false; // indicates whether DMA2D transfer *initi
|
|||
void lv_draw_stm32_dma2d_init(void)
|
||||
{
|
||||
// Enable DMA2D clock
|
||||
#if defined(STM32F4) || defined(STM32F7)
|
||||
#if defined(STM32F4) || defined(STM32F7) || defined(STM32U5)
|
||||
RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN; // enable DMA2D
|
||||
// wait for hardware access to complete
|
||||
__asm volatile("DSB\n");
|
||||
volatile uint32_t temp = RCC->AHB1ENR;
|
||||
LV_UNUSED(temp);
|
||||
#elif defined(STM32H7)
|
||||
RCC->AHB3ENR |= RCC_AHB3ENR_DMA2DEN;
|
||||
// wait for hardware access to complete
|
||||
__asm volatile("DSB\n");
|
||||
volatile uint32_t temp = RCC->AHB3ENR;
|
||||
LV_UNUSED(temp);
|
||||
#else
|
||||
# warning "LVGL can't enable the clock of DMA2D"
|
||||
#endif
|
||||
|
||||
// Wait for hardware access to complete
|
||||
__asm volatile("DSB\n");
|
||||
|
||||
// Delay after setting peripheral clock
|
||||
volatile uint32_t temp = RCC->AHB1ENR;
|
||||
LV_UNUSED(temp);
|
||||
|
||||
// AHB master timer configuration
|
||||
DMA2D->AMTCR = 0; // AHB bus guaranteed dead time disabled
|
||||
#if defined(LV_STM32_DMA2D_TEST)
|
||||
|
|
@ -206,7 +225,7 @@ static void lv_draw_stm32_dma2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw
|
|||
// lv_coord_t draw_width = lv_area_get_width(&draw_area);
|
||||
// lv_coord_t draw_height = lv_area_get_height(&draw_area);
|
||||
// uint32_t dest_address = (uint32_t)(draw_ctx->buf + (dest_stride * draw_area.y1) + draw_area.x1);
|
||||
// _lv_gpu_stm32_dma2d_clean_cache(dest_address, dest_stride - draw_width, draw_width, draw_height, sizeof(lv_color_t));
|
||||
// __lv_gpu_stm32_dma2d_clean_cache(dest_address, dest_stride - draw_width, draw_width, draw_height, sizeof(lv_color_t));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -412,7 +431,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_fill(const lv_color_t * de
|
|||
DMA2D->BGMAR = (uint32_t)(dest_buf + (dest_stride * draw_area->y1) + draw_area->x1);
|
||||
DMA2D->BGOR = dest_stride - draw_width;
|
||||
DMA2D->BGCOLR = 0; // used in A4 and A8 modes only
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
|
||||
DMA2D->OPFCCR = LvglColorFormat;
|
||||
#if defined(DMA2D_OPFCCR_RBS_Pos)
|
||||
|
|
@ -500,7 +519,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_map(const lv_color_t * des
|
|||
DMA2D->FGMAR = ((uint32_t)src_buf) + srcBpp * ((src_stride * src_offset->y) + src_offset->x);
|
||||
DMA2D->FGOR = src_stride - draw_width;
|
||||
DMA2D->FGCOLR = 0; // used in A4 and A8 modes only
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, srcBpp);
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, srcBpp);
|
||||
|
||||
DMA2D->OPFCCR = LvglColorFormat;
|
||||
#if defined(DMA2D_OPFCCR_RBS_Pos)
|
||||
|
|
@ -519,7 +538,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_map(const lv_color_t * des
|
|||
DMA2D->BGMAR = DMA2D->OMAR;
|
||||
DMA2D->BGOR = DMA2D->OOR;
|
||||
DMA2D->BGCOLR = 0; // used in A4 and A8 modes only
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
}
|
||||
|
||||
// PL - pixel per lines (14 bit), NL - number of lines (16 bit)
|
||||
|
|
@ -556,7 +575,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_paint(const lv_color_t * d
|
|||
DMA2D->FGMAR = (uint32_t)(mask_buf + (mask_stride * mask_offset->y) + mask_offset->x);
|
||||
DMA2D->FGOR = mask_stride - draw_width;
|
||||
DMA2D->FGCOLR = lv_color_to32(color) & 0x00ffffff; // swap FGCOLR R/B bits if FGPFCCR.RBS (RBS_BIT) bit is set
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_opa_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_opa_t));
|
||||
|
||||
DMA2D->BGPFCCR = LvglColorFormat;
|
||||
#if defined(DMA2D_BGPFCCR_RBS_Pos)
|
||||
|
|
@ -565,7 +584,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_paint(const lv_color_t * d
|
|||
DMA2D->BGMAR = (uint32_t)(dest_buf + (dest_stride * draw_area->y1) + draw_area->x1);
|
||||
DMA2D->BGOR = dest_stride - draw_width;
|
||||
DMA2D->BGCOLR = 0; // used in A4 and A8 modes only
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
|
||||
DMA2D->OPFCCR = LvglColorFormat;
|
||||
#if defined(DMA2D_OPFCCR_RBS_Pos)
|
||||
|
|
@ -602,7 +621,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_copy_buffer(const lv_color_t * d
|
|||
DMA2D->FGMAR = (uint32_t)(src_buf + (src_stride * src_offset->y) + src_offset->x);
|
||||
DMA2D->FGOR = src_stride - draw_width;
|
||||
DMA2D->FGCOLR = 0; // used in A4 and A8 modes only
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_color_t));
|
||||
|
||||
// Note BG* registers do not need to be set up since BG is not used
|
||||
|
||||
|
|
@ -627,8 +646,8 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_start_dma_transfer(void)
|
|||
DMA2D->IFCR = 0x3FU; // trigger ISR flags reset
|
||||
// Note: cleaning output buffer cache is needed only when buffer may be misaligned or adjacent area may have been drawn in sw-fashion, e.g. using lv_draw_sw_blend_basic()
|
||||
#if LV_COLOR_DEPTH == 16
|
||||
_lv_gpu_stm32_dma2d_clean_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos,
|
||||
(DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
|
||||
__lv_gpu_stm32_dma2d_clean_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos,
|
||||
(DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
|
||||
#endif
|
||||
DMA2D->CR |= DMA2D_CR_START;
|
||||
// Note: for some reason mask buffer gets damaged during transfer if waiting is postponed
|
||||
|
|
@ -660,15 +679,16 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_await_dma_transfer_finish(lv_disp
|
|||
|
||||
if(isDma2dInProgess) {
|
||||
// invalidate output buffer cached memory ONLY after DMA2D transfer
|
||||
//_lv_gpu_stm32_dma2d_invalidate_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos, (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
|
||||
//__lv_gpu_stm32_dma2d_invalidate_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos, (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
|
||||
isDma2dInProgess = false;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
|
||||
// Cortex-M7 DCache present
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
|
||||
lv_coord_t height, uint8_t pixel_size)
|
||||
{
|
||||
#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
|
||||
if(((SCB->CCR) & SCB_CCR_DC_Msk) == 0) return; // L1 data cache is disabled
|
||||
uint16_t stride = pixel_size * (width + offset); // in bytes
|
||||
uint16_t ll = pixel_size * width; // line length in bytes
|
||||
|
|
@ -694,13 +714,11 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address
|
|||
|
||||
__DSB();
|
||||
__ISB();
|
||||
#endif
|
||||
}
|
||||
|
||||
LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
|
||||
lv_coord_t height, uint8_t pixel_size)
|
||||
{
|
||||
#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
|
||||
if(((SCB->CCR) & SCB_CCR_DC_Msk) == 0) return; // L1 data cache is disabled
|
||||
uint16_t stride = pixel_size * (width + offset); // in bytes
|
||||
uint16_t ll = pixel_size * width; // line length in bytes
|
||||
|
|
@ -725,9 +743,10 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_
|
|||
|
||||
__DSB();
|
||||
__ISB();
|
||||
#endif
|
||||
}
|
||||
#endif // LV_STM32_DMA2D_USE_M7_CACHE
|
||||
|
||||
#if defined(LV_STM32_DMA2D_TEST)
|
||||
// initialize µs timer
|
||||
LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void)
|
||||
{
|
||||
|
|
@ -773,5 +792,5 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void)
|
|||
{
|
||||
DWT->CYCCNT = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif // LV_STM32_DMA2D_TEST
|
||||
#endif // LV_USE_GPU_STM32_DMA2D
|
||||
|
|
@ -103,7 +103,7 @@ void lv_draw_sw_letter(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc
|
|||
if(letter >= 0x20 &&
|
||||
letter != 0xf8ff && /*LV_SYMBOL_DUMMY*/
|
||||
letter != 0x200c) { /*ZERO WIDTH NON-JOINER*/
|
||||
LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%" PRIX32, letter);
|
||||
LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%" LV_PRIX32, letter);
|
||||
|
||||
#if LV_USE_FONT_PLACEHOLDER
|
||||
/* draw placeholder */
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ static void argb_and_rgb_aa(const uint8_t * src, lv_coord_t src_w, lv_coord_t sr
|
|||
int32_t ys_ups_start = ys_ups;
|
||||
bool has_alpha;
|
||||
int32_t px_size;
|
||||
lv_color_t ck = {0};
|
||||
lv_color_t ck = _LV_COLOR_ZERO_INITIALIZER;
|
||||
switch(cf) {
|
||||
case LV_IMG_CF_TRUE_COLOR:
|
||||
has_alpha = false;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,332 @@
|
|||
/**
|
||||
* @file lv_fs_littlefs.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_FS_LITTLEFS
|
||||
#include "lfs.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
#if LV_FS_LITTLEFS_LETTER == '\0'
|
||||
#error "LV_FS_LITTLEFS_LETTER must be an upper case ASCII letter"
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
|
||||
static void fs_init(void);
|
||||
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
void lv_fs_littlefs_init(void)
|
||||
{
|
||||
/*----------------------------------------------------
|
||||
* Initialize your storage device and File System
|
||||
* -------------------------------------------------*/
|
||||
fs_init();
|
||||
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple drive to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_LITTLEFS_LETTER;
|
||||
fs_drv.cache_size = LV_FS_LITTLEFS_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
/*#if LV_USE_USER_DATA*/
|
||||
fs_drv.user_data = NULL;
|
||||
/*#endif*/
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convenience function to attach registered driver to lfs_t structure by driver-label
|
||||
* @param label the label assigned to the driver when it was registered
|
||||
* @param lfs_p the pointer to the lfs_t structure initialized by external code/library
|
||||
* @return pointer to a driver descriptor or NULL on error
|
||||
*/
|
||||
lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p)
|
||||
{
|
||||
lv_fs_drv_t * drv_p = lv_fs_get_drv(label);
|
||||
if(drv_p != NULL) drv_p->user_data = (lfs_t *) lfs_p;
|
||||
return drv_p;
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/*Initialize your Storage device and File system.*/
|
||||
static void fs_init(void)
|
||||
{
|
||||
/* Initialize the internal flash or SD-card and LittleFS itself.
|
||||
* Better to do it in your code to keep this library untouched for easy updating */
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return pointer to a file descriptor or NULL on error
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
uint32_t flags = 0;
|
||||
|
||||
flags = mode == LV_FS_MODE_RD ? LFS_O_RDONLY
|
||||
: mode == LV_FS_MODE_WR ? LFS_O_WRONLY
|
||||
: mode == (LV_FS_MODE_WR | LV_FS_MODE_RD) ? LFS_O_RDWR : 0;
|
||||
|
||||
lfs_file_t * file_p = lv_mem_alloc(sizeof(lfs_file_t));
|
||||
if(file_p == NULL) return NULL;
|
||||
|
||||
int result = lfs_file_open(lfs_p, file_p, path, flags);
|
||||
|
||||
if(result != LFS_ERR_OK) {
|
||||
lv_mem_free(file_p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return file_p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int result = lfs_file_close(lfs_p, file_p);
|
||||
lv_mem_free(file_p);
|
||||
/*lv_mem_free( lfs_p );*/ /*allocated and freed by outside-code*/
|
||||
|
||||
if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_ssize_t result = lfs_file_read(lfs_p, file_p, buf, btr);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*br = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
#ifndef LFS_READONLY
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_ssize_t result = lfs_file_write(lfs_p, file_p, buf, btw);
|
||||
if(result < 0 || lfs_file_sync(lfs_p, file_p) < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*bw = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
#else
|
||||
return LV_FS_RES_NOT_IMP;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @param whence tells from where to interpret the `pos`. See @lv_fs_whence_t
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int lfs_whence = whence == LV_FS_SEEK_SET ? LFS_SEEK_SET
|
||||
: whence == LV_FS_SEEK_CUR ? LFS_SEEK_CUR
|
||||
: whence == LV_FS_SEEK_END ? LFS_SEEK_END : 0;
|
||||
|
||||
lfs_soff_t result = lfs_file_seek(lfs_p, file_p, pos, lfs_whence);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
/*pos = result;*/ /*not supported by lv_fs*/
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable.
|
||||
* @param pos_p pointer to where to store the result
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_soff_t result = lfs_file_tell(lfs_p, file_p);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*pos_p = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a 'lv_fs_dir_t' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to the directory read descriptor or NULL on error
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_dir_t * dir_p = lv_mem_alloc(sizeof(lfs_dir_t));
|
||||
if(dir_p == NULL) return NULL;
|
||||
|
||||
int result = lfs_dir_open(lfs_p, dir_p, path);
|
||||
if(result != LFS_ERR_OK) {
|
||||
lv_mem_free(dir_p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return dir_p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename form a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * rddir_p, char * fn)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
struct lfs_info info;
|
||||
int result;
|
||||
|
||||
info.name[0] = '\0';
|
||||
|
||||
do {
|
||||
result = lfs_dir_read(lfs_p, rddir_p, &info);
|
||||
if(result > 0) {
|
||||
if(info.type == LFS_TYPE_DIR) {
|
||||
fn[0] = '/';
|
||||
strcpy(&fn[1], info.name);
|
||||
}
|
||||
else strcpy(fn, info.name);
|
||||
}
|
||||
else if(result == 0) fn[0] = '\0'; /*dir-scan ended*/
|
||||
else return LV_FS_RES_UNKNOWN;
|
||||
|
||||
} while(!strcmp(fn, "/.") || !strcmp(fn, "/.."));
|
||||
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * rddir_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int result = lfs_dir_close(lfs_p, rddir_p);
|
||||
lv_mem_free(rddir_p);
|
||||
|
||||
if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
#else /*LV_USE_FS_LITTLEFS == 0*/
|
||||
|
||||
#if defined(LV_FS_LITTLEFS_LETTER) && LV_FS_LITTLEFS_LETTER != '\0'
|
||||
#warning "LV_USE_FS_LITTLEFS is not enabled but LV_FS_LITTLEFS_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif /*LV_USE_FS_POSIX*/
|
||||
|
|
@ -31,6 +31,11 @@ extern "C" {
|
|||
void lv_fs_fatfs_init(void);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_LITTLEFS != '\0'
|
||||
void lv_fs_littlefs_init(void);
|
||||
lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_STDIO != '\0'
|
||||
void lv_fs_stdio_init(void);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ extern "C" {
|
|||
#include "freetype/lv_freetype.h"
|
||||
#include "rlottie/lv_rlottie.h"
|
||||
#include "ffmpeg/lv_ffmpeg.h"
|
||||
#include "tiny_ttf/lv_tiny_ttf.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@
|
|||
* Software.
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "qrcodegen.h"
|
||||
#include "../../../misc/lv_assert.h"
|
||||
|
||||
#ifndef QRCODEGEN_TEST
|
||||
#define testable static // Keep functions private
|
||||
|
|
@ -127,12 +127,12 @@ static const int PENALTY_N4 = 10;
|
|||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
|
||||
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl) {
|
||||
|
||||
|
||||
size_t textLen = strlen(text);
|
||||
if (textLen == 0)
|
||||
return qrcodegen_encodeSegmentsAdvanced(NULL, 0, ecl, minVersion, maxVersion, mask, boostEcl, tempBuffer, qrcode);
|
||||
size_t bufLen = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion);
|
||||
|
||||
|
||||
struct qrcodegen_Segment seg;
|
||||
if (qrcodegen_isNumeric(text)) {
|
||||
if (qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, textLen) > bufLen)
|
||||
|
|
@ -155,7 +155,7 @@ bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode
|
|||
seg.data = tempBuffer;
|
||||
}
|
||||
return qrcodegen_encodeSegmentsAdvanced(&seg, 1, ecl, minVersion, maxVersion, mask, boostEcl, tempBuffer, qrcode);
|
||||
|
||||
|
||||
fail:
|
||||
qrcode[0] = 0; // Set size to invalid value for safety
|
||||
return false;
|
||||
|
|
@ -165,7 +165,7 @@ fail:
|
|||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
|
||||
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl) {
|
||||
|
||||
|
||||
struct qrcodegen_Segment seg;
|
||||
seg.mode = qrcodegen_Mode_BYTE;
|
||||
seg.bitLength = calcSegmentBitLength(seg.mode, dataLen);
|
||||
|
|
@ -182,7 +182,7 @@ bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcod
|
|||
// Appends the given number of low-order bits of the given value to the given byte-based
|
||||
// bit buffer, increasing the bit length. Requires 0 <= numBits <= 16 and val < 2^numBits.
|
||||
testable void appendBitsToBuffer(unsigned int val, int numBits, uint8_t buffer[], int *bitLen) {
|
||||
assert(0 <= numBits && numBits <= 16 && (unsigned long)val >> numBits == 0);
|
||||
LV_ASSERT(0 <= numBits && numBits <= 16 && (unsigned long)val >> numBits == 0);
|
||||
for (int i = numBits - 1; i >= 0; i--, (*bitLen)++)
|
||||
buffer[*bitLen >> 3] |= ((val >> i) & 1) << (7 - (*bitLen & 7));
|
||||
}
|
||||
|
|
@ -202,10 +202,10 @@ bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
|
|||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
|
||||
int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]) {
|
||||
assert(segs != NULL || len == 0);
|
||||
assert(qrcodegen_VERSION_MIN <= minVersion && minVersion <= maxVersion && maxVersion <= qrcodegen_VERSION_MAX);
|
||||
assert(0 <= (int)ecl && (int)ecl <= 3 && -1 <= (int)mask && (int)mask <= 7);
|
||||
|
||||
LV_ASSERT(segs != NULL || len == 0);
|
||||
LV_ASSERT(qrcodegen_VERSION_MIN <= minVersion && minVersion <= maxVersion && maxVersion <= qrcodegen_VERSION_MAX);
|
||||
LV_ASSERT(0 <= (int)ecl && (int)ecl <= 3 && -1 <= (int)mask && (int)mask <= 7);
|
||||
|
||||
// Find the minimal version number to use
|
||||
int version, dataUsedBits;
|
||||
for (version = minVersion; ; version++) {
|
||||
|
|
@ -218,14 +218,14 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
|
|||
return false;
|
||||
}
|
||||
}
|
||||
assert(dataUsedBits != -1);
|
||||
|
||||
LV_ASSERT(dataUsedBits != -1);
|
||||
|
||||
// Increase the error correction level while the data still fits in the current version number
|
||||
for (int i = (int)qrcodegen_Ecc_MEDIUM; i <= (int)qrcodegen_Ecc_HIGH; i++) { // From low to high
|
||||
if (boostEcl && dataUsedBits <= getNumDataCodewords(version, (enum qrcodegen_Ecc)i) * 8)
|
||||
ecl = (enum qrcodegen_Ecc)i;
|
||||
}
|
||||
|
||||
|
||||
// Concatenate all segments to create the data bit string
|
||||
memset(qrcode, 0, qrcodegen_BUFFER_LEN_FOR_VERSION(version) * sizeof(qrcode[0]));
|
||||
int bitLen = 0;
|
||||
|
|
@ -236,29 +236,29 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
|
|||
for (int j = 0; j < seg->bitLength; j++)
|
||||
appendBitsToBuffer((seg->data[j >> 3] >> (7 - (j & 7))) & 1, 1, qrcode, &bitLen);
|
||||
}
|
||||
assert(bitLen == dataUsedBits);
|
||||
|
||||
LV_ASSERT(bitLen == dataUsedBits);
|
||||
|
||||
// Add terminator and pad up to a byte if applicable
|
||||
int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
|
||||
assert(bitLen <= dataCapacityBits);
|
||||
LV_ASSERT(bitLen <= dataCapacityBits);
|
||||
int terminatorBits = dataCapacityBits - bitLen;
|
||||
if (terminatorBits > 4)
|
||||
terminatorBits = 4;
|
||||
appendBitsToBuffer(0, terminatorBits, qrcode, &bitLen);
|
||||
appendBitsToBuffer(0, (8 - bitLen % 8) % 8, qrcode, &bitLen);
|
||||
assert(bitLen % 8 == 0);
|
||||
|
||||
LV_ASSERT(bitLen % 8 == 0);
|
||||
|
||||
// Pad with alternating bytes until data capacity is reached
|
||||
for (uint8_t padByte = 0xEC; bitLen < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
|
||||
appendBitsToBuffer(padByte, 8, qrcode, &bitLen);
|
||||
|
||||
|
||||
// Draw function and data codeword modules
|
||||
addEccAndInterleave(qrcode, version, ecl, tempBuffer);
|
||||
initializeFunctionModules(version, qrcode);
|
||||
drawCodewords(tempBuffer, getNumRawDataModules(version) / 8, qrcode);
|
||||
drawWhiteFunctionModules(qrcode, version);
|
||||
initializeFunctionModules(version, tempBuffer);
|
||||
|
||||
|
||||
// Handle masking
|
||||
if (mask == qrcodegen_Mask_AUTO) { // Automatically choose best mask
|
||||
long minPenalty = LONG_MAX;
|
||||
|
|
@ -274,7 +274,7 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
|
|||
applyMask(tempBuffer, qrcode, msk); // Undoes the mask due to XOR
|
||||
}
|
||||
}
|
||||
assert(0 <= (int)mask && (int)mask <= 7);
|
||||
LV_ASSERT(0 <= (int)mask && (int)mask <= 7);
|
||||
applyMask(tempBuffer, qrcode, mask);
|
||||
drawFormatBits(ecl, mask, qrcode);
|
||||
return true;
|
||||
|
|
@ -290,14 +290,14 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
|
|||
// be clobbered by this function. The final answer is stored in result[0 : rawCodewords].
|
||||
testable void addEccAndInterleave(uint8_t data[], int version, enum qrcodegen_Ecc ecl, uint8_t result[]) {
|
||||
// Calculate parameter numbers
|
||||
assert(0 <= (int)ecl && (int)ecl < 4 && qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
|
||||
LV_ASSERT(0 <= (int)ecl && (int)ecl < 4 && qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
|
||||
int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[(int)ecl][version];
|
||||
int blockEccLen = ECC_CODEWORDS_PER_BLOCK [(int)ecl][version];
|
||||
int rawCodewords = getNumRawDataModules(version) / 8;
|
||||
int dataLen = getNumDataCodewords(version, ecl);
|
||||
int numShortBlocks = numBlocks - rawCodewords % numBlocks;
|
||||
int shortBlockDataLen = rawCodewords / numBlocks - blockEccLen;
|
||||
|
||||
|
||||
// Split data into blocks, calculate ECC, and interleave
|
||||
// (not concatenate) the bytes into a single sequence
|
||||
uint8_t generator[qrcodegen_REED_SOLOMON_DEGREE_MAX];
|
||||
|
|
@ -323,7 +323,7 @@ testable void addEccAndInterleave(uint8_t data[], int version, enum qrcodegen_Ec
|
|||
// for the given version number and error correction level. The result is in the range [9, 2956].
|
||||
testable int getNumDataCodewords(int version, enum qrcodegen_Ecc ecl) {
|
||||
int v = version, e = (int)ecl;
|
||||
assert(0 <= e && e < 4);
|
||||
LV_ASSERT(0 <= e && e < 4);
|
||||
return getNumRawDataModules(v) / 8
|
||||
- ECC_CODEWORDS_PER_BLOCK [e][v]
|
||||
* NUM_ERROR_CORRECTION_BLOCKS[e][v];
|
||||
|
|
@ -334,7 +334,7 @@ testable int getNumDataCodewords(int version, enum qrcodegen_Ecc ecl) {
|
|||
// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
|
||||
// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
|
||||
testable int getNumRawDataModules(int ver) {
|
||||
assert(qrcodegen_VERSION_MIN <= ver && ver <= qrcodegen_VERSION_MAX);
|
||||
LV_ASSERT(qrcodegen_VERSION_MIN <= ver && ver <= qrcodegen_VERSION_MAX);
|
||||
int result = (16 * ver + 128) * ver + 64;
|
||||
if (ver >= 2) {
|
||||
int numAlign = ver / 7 + 2;
|
||||
|
|
@ -352,10 +352,10 @@ testable int getNumRawDataModules(int ver) {
|
|||
// Calculates the Reed-Solomon generator polynomial of the given degree, storing in result[0 : degree].
|
||||
testable void calcReedSolomonGenerator(int degree, uint8_t result[]) {
|
||||
// Start with the monomial x^0
|
||||
assert(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
|
||||
LV_ASSERT(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
|
||||
memset(result, 0, degree * sizeof(result[0]));
|
||||
result[degree - 1] = 1;
|
||||
|
||||
|
||||
// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
|
||||
// drop the highest term, and store the rest of the coefficients in order of descending powers.
|
||||
// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
|
||||
|
|
@ -376,9 +376,9 @@ testable void calcReedSolomonGenerator(int degree, uint8_t result[]) {
|
|||
// polynomials are in big endian and the generator has an implicit leading 1 term, storing the result in result[0 : degree].
|
||||
testable void calcReedSolomonRemainder(const uint8_t data[], int dataLen,
|
||||
const uint8_t generator[], int degree, uint8_t result[]) {
|
||||
|
||||
|
||||
// Perform polynomial division
|
||||
assert(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
|
||||
LV_ASSERT(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
|
||||
memset(result, 0, degree * sizeof(result[0]));
|
||||
for (int i = 0; i < dataLen; i++) {
|
||||
uint8_t factor = data[i] ^ result[0];
|
||||
|
|
@ -415,16 +415,16 @@ testable void initializeFunctionModules(int version, uint8_t qrcode[]) {
|
|||
int qrsize = version * 4 + 17;
|
||||
memset(qrcode, 0, ((qrsize * qrsize + 7) / 8 + 1) * sizeof(qrcode[0]));
|
||||
qrcode[0] = (uint8_t)qrsize;
|
||||
|
||||
|
||||
// Fill horizontal and vertical timing patterns
|
||||
fillRectangle(6, 0, 1, qrsize, qrcode);
|
||||
fillRectangle(0, 6, qrsize, 1, qrcode);
|
||||
|
||||
|
||||
// Fill 3 finder patterns (all corners except bottom right) and format bits
|
||||
fillRectangle(0, 0, 9, 9, qrcode);
|
||||
fillRectangle(qrsize - 8, 0, 8, 9, qrcode);
|
||||
fillRectangle(0, qrsize - 8, 9, 8, qrcode);
|
||||
|
||||
|
||||
// Fill numerous alignment patterns
|
||||
uint8_t alignPatPos[7];
|
||||
int numAlign = getAlignmentPatternPositions(version, alignPatPos);
|
||||
|
|
@ -435,7 +435,7 @@ testable void initializeFunctionModules(int version, uint8_t qrcode[]) {
|
|||
fillRectangle(alignPatPos[i] - 2, alignPatPos[j] - 2, 5, 5, qrcode);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Fill version blocks
|
||||
if (version >= 7) {
|
||||
fillRectangle(qrsize - 11, 0, 3, 6, qrcode);
|
||||
|
|
@ -454,7 +454,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
|
|||
setModule(qrcode, 6, i, false);
|
||||
setModule(qrcode, i, 6, false);
|
||||
}
|
||||
|
||||
|
||||
// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
|
||||
for (int dy = -4; dy <= 4; dy++) {
|
||||
for (int dx = -4; dx <= 4; dx++) {
|
||||
|
|
@ -468,7 +468,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Draw numerous alignment patterns
|
||||
uint8_t alignPatPos[7];
|
||||
int numAlign = getAlignmentPatternPositions(version, alignPatPos);
|
||||
|
|
@ -482,7 +482,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Draw version blocks
|
||||
if (version >= 7) {
|
||||
// Calculate error correction code and pack bits
|
||||
|
|
@ -490,8 +490,8 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
|
|||
for (int i = 0; i < 12; i++)
|
||||
rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
|
||||
long bits = (long)version << 12 | rem; // uint18
|
||||
assert(bits >> 18 == 0);
|
||||
|
||||
LV_ASSERT(bits >> 18 == 0);
|
||||
|
||||
// Draw two copies
|
||||
for (int i = 0; i < 6; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
|
|
@ -510,15 +510,15 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
|
|||
// the format bits, unlike drawWhiteFunctionModules() which might skip black modules.
|
||||
static void drawFormatBits(enum qrcodegen_Ecc ecl, enum qrcodegen_Mask mask, uint8_t qrcode[]) {
|
||||
// Calculate error correction code and pack bits
|
||||
assert(0 <= (int)mask && (int)mask <= 7);
|
||||
LV_ASSERT(0 <= (int)mask && (int)mask <= 7);
|
||||
static const int table[] = {1, 0, 3, 2};
|
||||
int data = table[(int)ecl] << 3 | (int)mask; // errCorrLvl is uint2, mask is uint3
|
||||
int rem = data;
|
||||
for (int i = 0; i < 10; i++)
|
||||
rem = (rem << 1) ^ ((rem >> 9) * 0x537);
|
||||
int bits = (data << 10 | rem) ^ 0x5412; // uint15
|
||||
assert(bits >> 15 == 0);
|
||||
|
||||
LV_ASSERT(bits >> 15 == 0);
|
||||
|
||||
// Draw first copy
|
||||
for (int i = 0; i <= 5; i++)
|
||||
setModule(qrcode, 8, i, getBit(bits, i));
|
||||
|
|
@ -527,7 +527,7 @@ static void drawFormatBits(enum qrcodegen_Ecc ecl, enum qrcodegen_Mask mask, uin
|
|||
setModule(qrcode, 7, 8, getBit(bits, 8));
|
||||
for (int i = 9; i < 15; i++)
|
||||
setModule(qrcode, 14 - i, 8, getBit(bits, i));
|
||||
|
||||
|
||||
// Draw second copy
|
||||
int qrsize = qrcodegen_getSize(qrcode);
|
||||
for (int i = 0; i < 8; i++)
|
||||
|
|
@ -591,7 +591,7 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
|
|||
}
|
||||
}
|
||||
}
|
||||
assert(i == dataLen * 8);
|
||||
LV_ASSERT(i == dataLen * 8);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -601,7 +601,7 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
|
|||
// the same mask value a second time will undo the mask. A final well-formed
|
||||
// QR Code needs exactly one (not zero, two, etc.) mask applied.
|
||||
static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qrcodegen_Mask mask) {
|
||||
assert(0 <= (int)mask && (int)mask <= 7); // Disallows qrcodegen_Mask_AUTO
|
||||
LV_ASSERT(0 <= (int)mask && (int)mask <= 7); // Disallows qrcodegen_Mask_AUTO
|
||||
int qrsize = qrcodegen_getSize(qrcode);
|
||||
for (int y = 0; y < qrsize; y++) {
|
||||
for (int x = 0; x < qrsize; x++) {
|
||||
|
|
@ -617,7 +617,7 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
|
|||
case 5: invert = x * y % 2 + x * y % 3 == 0; break;
|
||||
case 6: invert = (x * y % 2 + x * y % 3) % 2 == 0; break;
|
||||
case 7: invert = ((x + y) % 2 + x * y % 3) % 2 == 0; break;
|
||||
default: assert(false); return;
|
||||
default: LV_ASSERT(false); return;
|
||||
}
|
||||
bool val = getModule(qrcode, x, y);
|
||||
setModule(qrcode, x, y, val ^ invert);
|
||||
|
|
@ -631,7 +631,7 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
|
|||
static long getPenaltyScore(const uint8_t qrcode[]) {
|
||||
int qrsize = qrcodegen_getSize(qrcode);
|
||||
long result = 0;
|
||||
|
||||
|
||||
// Adjacent modules in row having same color, and finder-like patterns
|
||||
for (int y = 0; y < qrsize; y++) {
|
||||
unsigned char runHistory[7] = {0};
|
||||
|
|
@ -684,7 +684,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
|
|||
if (hasFinderLikePattern(runHistory))
|
||||
result += PENALTY_N3;
|
||||
}
|
||||
|
||||
|
||||
// 2*2 blocks of modules having same color
|
||||
for (int y = 0; y < qrsize - 1; y++) {
|
||||
for (int x = 0; x < qrsize - 1; x++) {
|
||||
|
|
@ -695,7 +695,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
|
|||
result += PENALTY_N2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Balance of black and white modules
|
||||
int black = 0;
|
||||
for (int y = 0; y < qrsize; y++) {
|
||||
|
|
@ -737,9 +737,9 @@ static bool hasFinderLikePattern(const unsigned char runHistory[7]) {
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
int qrcodegen_getSize(const uint8_t qrcode[]) {
|
||||
assert(qrcode != NULL);
|
||||
LV_ASSERT(qrcode != NULL);
|
||||
int result = qrcode[0];
|
||||
assert((qrcodegen_VERSION_MIN * 4 + 17) <= result
|
||||
LV_ASSERT((qrcodegen_VERSION_MIN * 4 + 17) <= result
|
||||
&& result <= (qrcodegen_VERSION_MAX * 4 + 17));
|
||||
return result;
|
||||
}
|
||||
|
|
@ -747,7 +747,7 @@ int qrcodegen_getSize(const uint8_t qrcode[]) {
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y) {
|
||||
assert(qrcode != NULL);
|
||||
LV_ASSERT(qrcode != NULL);
|
||||
int qrsize = qrcode[0];
|
||||
return (0 <= x && x < qrsize && 0 <= y && y < qrsize) && getModule(qrcode, x, y);
|
||||
}
|
||||
|
|
@ -756,7 +756,7 @@ bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y) {
|
|||
// Gets the module at the given coordinates, which must be in bounds.
|
||||
testable bool getModule(const uint8_t qrcode[], int x, int y) {
|
||||
int qrsize = qrcode[0];
|
||||
assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
|
||||
LV_ASSERT(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
|
||||
int index = y * qrsize + x;
|
||||
return getBit(qrcode[(index >> 3) + 1], index & 7);
|
||||
}
|
||||
|
|
@ -765,7 +765,7 @@ testable bool getModule(const uint8_t qrcode[], int x, int y) {
|
|||
// Sets the module at the given coordinates, which must be in bounds.
|
||||
testable void setModule(uint8_t qrcode[], int x, int y, bool isBlack) {
|
||||
int qrsize = qrcode[0];
|
||||
assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
|
||||
LV_ASSERT(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
|
||||
int index = y * qrsize + x;
|
||||
int bitIndex = index & 7;
|
||||
int byteIndex = (index >> 3) + 1;
|
||||
|
|
@ -795,7 +795,7 @@ static bool getBit(int x, int i) {
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_isAlphanumeric(const char *text) {
|
||||
assert(text != NULL);
|
||||
LV_ASSERT(text != NULL);
|
||||
for (; *text != '\0'; text++) {
|
||||
if (strchr(ALPHANUMERIC_CHARSET, *text) == NULL)
|
||||
return false;
|
||||
|
|
@ -806,7 +806,7 @@ bool qrcodegen_isAlphanumeric(const char *text) {
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
bool qrcodegen_isNumeric(const char *text) {
|
||||
assert(text != NULL);
|
||||
LV_ASSERT(text != NULL);
|
||||
for (; *text != '\0'; text++) {
|
||||
if (*text < '0' || *text > '9')
|
||||
return false;
|
||||
|
|
@ -820,7 +820,7 @@ size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars
|
|||
int temp = calcSegmentBitLength(mode, numChars);
|
||||
if (temp == -1)
|
||||
return SIZE_MAX;
|
||||
assert(0 <= temp && temp <= INT16_MAX);
|
||||
LV_ASSERT(0 <= temp && temp <= INT16_MAX);
|
||||
return ((size_t)temp + 7) / 8;
|
||||
}
|
||||
|
||||
|
|
@ -849,10 +849,10 @@ testable int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars) {
|
|||
else if (mode == qrcodegen_Mode_ECI && numChars == 0)
|
||||
result = 3 * 8;
|
||||
else { // Invalid argument
|
||||
assert(false);
|
||||
LV_ASSERT(false);
|
||||
return -1;
|
||||
}
|
||||
assert(result >= 0);
|
||||
LV_ASSERT(result >= 0);
|
||||
if ((unsigned int)result > (unsigned int)INT16_MAX)
|
||||
return -1;
|
||||
return (int)result;
|
||||
|
|
@ -861,11 +861,11 @@ testable int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars) {
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]) {
|
||||
assert(data != NULL || len == 0);
|
||||
LV_ASSERT(data != NULL || len == 0);
|
||||
struct qrcodegen_Segment result;
|
||||
result.mode = qrcodegen_Mode_BYTE;
|
||||
result.bitLength = calcSegmentBitLength(result.mode, len);
|
||||
assert(result.bitLength != -1);
|
||||
LV_ASSERT(result.bitLength != -1);
|
||||
result.numChars = (int)len;
|
||||
if (len > 0)
|
||||
memcpy(buf, data, len * sizeof(buf[0]));
|
||||
|
|
@ -876,22 +876,22 @@ struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, u
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]) {
|
||||
assert(digits != NULL);
|
||||
LV_ASSERT(digits != NULL);
|
||||
struct qrcodegen_Segment result;
|
||||
size_t len = strlen(digits);
|
||||
result.mode = qrcodegen_Mode_NUMERIC;
|
||||
int bitLen = calcSegmentBitLength(result.mode, len);
|
||||
assert(bitLen != -1);
|
||||
LV_ASSERT(bitLen != -1);
|
||||
result.numChars = (int)len;
|
||||
if (bitLen > 0)
|
||||
memset(buf, 0, ((size_t)bitLen + 7) / 8 * sizeof(buf[0]));
|
||||
result.bitLength = 0;
|
||||
|
||||
|
||||
unsigned int accumData = 0;
|
||||
int accumCount = 0;
|
||||
for (; *digits != '\0'; digits++) {
|
||||
char c = *digits;
|
||||
assert('0' <= c && c <= '9');
|
||||
LV_ASSERT('0' <= c && c <= '9');
|
||||
accumData = accumData * 10 + (unsigned int)(c - '0');
|
||||
accumCount++;
|
||||
if (accumCount == 3) {
|
||||
|
|
@ -902,7 +902,7 @@ struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]
|
|||
}
|
||||
if (accumCount > 0) // 1 or 2 digits remaining
|
||||
appendBitsToBuffer(accumData, accumCount * 3 + 1, buf, &result.bitLength);
|
||||
assert(result.bitLength == bitLen);
|
||||
LV_ASSERT(result.bitLength == bitLen);
|
||||
result.data = buf;
|
||||
return result;
|
||||
}
|
||||
|
|
@ -910,22 +910,22 @@ struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]
|
|||
|
||||
// Public function - see documentation comment in header file.
|
||||
struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]) {
|
||||
assert(text != NULL);
|
||||
LV_ASSERT(text != NULL);
|
||||
struct qrcodegen_Segment result;
|
||||
size_t len = strlen(text);
|
||||
result.mode = qrcodegen_Mode_ALPHANUMERIC;
|
||||
int bitLen = calcSegmentBitLength(result.mode, len);
|
||||
assert(bitLen != -1);
|
||||
LV_ASSERT(bitLen != -1);
|
||||
result.numChars = (int)len;
|
||||
if (bitLen > 0)
|
||||
memset(buf, 0, ((size_t)bitLen + 7) / 8 * sizeof(buf[0]));
|
||||
result.bitLength = 0;
|
||||
|
||||
|
||||
unsigned int accumData = 0;
|
||||
int accumCount = 0;
|
||||
for (; *text != '\0'; text++) {
|
||||
const char *temp = strchr(ALPHANUMERIC_CHARSET, *text);
|
||||
assert(temp != NULL);
|
||||
LV_ASSERT(temp != NULL);
|
||||
accumData = accumData * 45 + (unsigned int)(temp - ALPHANUMERIC_CHARSET);
|
||||
accumCount++;
|
||||
if (accumCount == 2) {
|
||||
|
|
@ -936,7 +936,7 @@ struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t bu
|
|||
}
|
||||
if (accumCount > 0) // 1 character remaining
|
||||
appendBitsToBuffer(accumData, 6, buf, &result.bitLength);
|
||||
assert(result.bitLength == bitLen);
|
||||
LV_ASSERT(result.bitLength == bitLen);
|
||||
result.data = buf;
|
||||
return result;
|
||||
}
|
||||
|
|
@ -949,7 +949,7 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
|
|||
result.numChars = 0;
|
||||
result.bitLength = 0;
|
||||
if (assignVal < 0) {
|
||||
assert(false);
|
||||
LV_ASSERT(false);
|
||||
} else if (assignVal < (1 << 7)) {
|
||||
memset(buf, 0, 1 * sizeof(buf[0]));
|
||||
appendBitsToBuffer(assignVal, 8, buf, &result.bitLength);
|
||||
|
|
@ -963,7 +963,7 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
|
|||
appendBitsToBuffer(assignVal >> 10, 11, buf, &result.bitLength);
|
||||
appendBitsToBuffer(assignVal & 0x3FF, 10, buf, &result.bitLength);
|
||||
} else {
|
||||
assert(false);
|
||||
LV_ASSERT(false);
|
||||
}
|
||||
result.data = buf;
|
||||
return result;
|
||||
|
|
@ -974,22 +974,22 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
|
|||
// Returns a non-negative number if successful. Otherwise returns -1 if a segment has too
|
||||
// many characters to fit its length field, or the total bits exceeds INT16_MAX.
|
||||
testable int getTotalBits(const struct qrcodegen_Segment segs[], size_t len, int version) {
|
||||
assert(segs != NULL || len == 0);
|
||||
LV_ASSERT(segs != NULL || len == 0);
|
||||
long result = 0;
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
int numChars = segs[i].numChars;
|
||||
int bitLength = segs[i].bitLength;
|
||||
assert(0 <= numChars && numChars <= INT16_MAX);
|
||||
assert(0 <= bitLength && bitLength <= INT16_MAX);
|
||||
LV_ASSERT(0 <= numChars && numChars <= INT16_MAX);
|
||||
LV_ASSERT(0 <= bitLength && bitLength <= INT16_MAX);
|
||||
int ccbits = numCharCountBits(segs[i].mode, version);
|
||||
assert(0 <= ccbits && ccbits <= 16);
|
||||
LV_ASSERT(0 <= ccbits && ccbits <= 16);
|
||||
if (numChars >= (1L << ccbits))
|
||||
return -1; // The segment's length doesn't fit the field's bit width
|
||||
result += 4L + ccbits + bitLength;
|
||||
if (result > INT16_MAX)
|
||||
return -1; // The sum might overflow an int type
|
||||
}
|
||||
assert(0 <= result && result <= INT16_MAX);
|
||||
LV_ASSERT(0 <= result && result <= INT16_MAX);
|
||||
return (int)result;
|
||||
}
|
||||
|
||||
|
|
@ -997,7 +997,7 @@ testable int getTotalBits(const struct qrcodegen_Segment segs[], size_t len, int
|
|||
// Returns the bit width of the character count field for a segment in the given mode
|
||||
// in a QR Code at the given version number. The result is in the range [0, 16].
|
||||
static int numCharCountBits(enum qrcodegen_Mode mode, int version) {
|
||||
assert(qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
|
||||
LV_ASSERT(qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
|
||||
int i = (version + 7) / 17;
|
||||
switch (mode) {
|
||||
case qrcodegen_Mode_NUMERIC : { static const int temp[] = {10, 12, 14}; return temp[i]; }
|
||||
|
|
@ -1005,7 +1005,7 @@ static int numCharCountBits(enum qrcodegen_Mode mode, int version) {
|
|||
case qrcodegen_Mode_BYTE : { static const int temp[] = { 8, 16, 16}; return temp[i]; }
|
||||
case qrcodegen_Mode_KANJI : { static const int temp[] = { 8, 10, 12}; return temp[i]; }
|
||||
case qrcodegen_Mode_ECI : return 0;
|
||||
default: assert(false); return -1; // Dummy value
|
||||
default: LV_ASSERT(false); return -1; // Dummy value
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,284 @@
|
|||
#include "lv_tiny_ttf.h"
|
||||
|
||||
#if LV_USE_TINY_TTF
|
||||
#include <stdio.h>
|
||||
#include "../../../misc/lv_lru.h"
|
||||
|
||||
#define STB_RECT_PACK_IMPLEMENTATION
|
||||
#define STBRP_STATIC
|
||||
#define STBTT_STATIC
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#define STBTT_HEAP_FACTOR_SIZE_32 50
|
||||
#define STBTT_HEAP_FACTOR_SIZE_128 20
|
||||
#define STBTT_HEAP_FACTOR_SIZE_DEFAULT 10
|
||||
#define STBTT_malloc(x, u) ((void)(u), lv_mem_alloc(x))
|
||||
#define STBTT_free(x, u) ((void)(u), lv_mem_free(x))
|
||||
#define TTF_MALLOC(x) (lv_mem_alloc(x))
|
||||
#define TTF_FREE(x) (lv_mem_free(x))
|
||||
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
/* a hydra stream that can be in memory or from a file*/
|
||||
typedef struct ttf_cb_stream {
|
||||
lv_fs_file_t * file;
|
||||
const void * data;
|
||||
size_t size;
|
||||
size_t position;
|
||||
} ttf_cb_stream_t;
|
||||
|
||||
static void ttf_cb_stream_read(ttf_cb_stream_t * stream, void * data, size_t to_read)
|
||||
{
|
||||
if(stream->file != NULL) {
|
||||
uint32_t br;
|
||||
lv_fs_read(stream->file, data, to_read, &br);
|
||||
}
|
||||
else {
|
||||
if(to_read + stream->position >= stream->size) {
|
||||
to_read = stream->size - stream->position;
|
||||
}
|
||||
lv_memcpy(data, ((const unsigned char *)stream->data + stream->position), to_read);
|
||||
stream->position += to_read;
|
||||
}
|
||||
}
|
||||
static void ttf_cb_stream_seek(ttf_cb_stream_t * stream, size_t position)
|
||||
{
|
||||
if(stream->file != NULL) {
|
||||
lv_fs_seek(stream->file, position, LV_FS_SEEK_SET);
|
||||
}
|
||||
else {
|
||||
if(position > stream->size) {
|
||||
stream->position = stream->size;
|
||||
}
|
||||
else {
|
||||
stream->position = position;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* for stream support */
|
||||
#define STBTT_STREAM_TYPE ttf_cb_stream_t *
|
||||
#define STBTT_STREAM_SEEK(s, x) ttf_cb_stream_seek(s, x);
|
||||
#define STBTT_STREAM_READ(s, x, y) ttf_cb_stream_read(s, x, y);
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
|
||||
#include "stb_rect_pack.h"
|
||||
#include "stb_truetype_htcw.h"
|
||||
|
||||
typedef struct ttf_font_desc {
|
||||
lv_fs_file_t file;
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
ttf_cb_stream_t stream;
|
||||
#else
|
||||
const uint8_t * stream;
|
||||
#endif
|
||||
stbtt_fontinfo info;
|
||||
float scale;
|
||||
int ascent;
|
||||
int descent;
|
||||
lv_lru_t * bitmap_cache;
|
||||
} ttf_font_desc_t;
|
||||
|
||||
typedef struct ttf_bitmap_cache_key {
|
||||
uint32_t unicode_letter;
|
||||
lv_coord_t line_height;
|
||||
} ttf_bitmap_cache_key_t;
|
||||
|
||||
static bool ttf_get_glyph_dsc_cb(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter,
|
||||
uint32_t unicode_letter_next)
|
||||
{
|
||||
if(unicode_letter < 0x20 ||
|
||||
unicode_letter == 0xf8ff || /*LV_SYMBOL_DUMMY*/
|
||||
unicode_letter == 0x200c) { /*ZERO WIDTH NON-JOINER*/
|
||||
dsc_out->box_w = 0;
|
||||
dsc_out->adv_w = 0;
|
||||
dsc_out->box_h = 0; /*height of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = 0; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = 0; /*Y offset of the bitmap in [pf]*/
|
||||
dsc_out->bpp = 0;
|
||||
dsc_out->is_placeholder = false;
|
||||
return true;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
int g1 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter);
|
||||
if(g1 == 0) {
|
||||
/* Glyph not found */
|
||||
return false;
|
||||
}
|
||||
int x1, y1, x2, y2;
|
||||
|
||||
stbtt_GetGlyphBitmapBox(&dsc->info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
|
||||
int g2 = 0;
|
||||
if(unicode_letter_next != 0) {
|
||||
g2 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter_next);
|
||||
}
|
||||
int advw, lsb;
|
||||
stbtt_GetGlyphHMetrics(&dsc->info, g1, &advw, &lsb);
|
||||
int k = stbtt_GetGlyphKernAdvance(&dsc->info, g1, g2);
|
||||
dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
|
||||
0.5f); /*Horizontal space required by the glyph in [px]*/
|
||||
|
||||
dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
|
||||
0.5f); /*Horizontal space required by the glyph in [px]*/
|
||||
dsc_out->box_w = (x2 - x1 + 1); /*width of the bitmap in [px]*/
|
||||
dsc_out->box_h = (y2 - y1 + 1); /*height of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = x1; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = -y2; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bits per pixel: 1/2/4/8*/
|
||||
dsc_out->is_placeholder = false;
|
||||
return true; /*true: glyph found; false: glyph was not found*/
|
||||
}
|
||||
|
||||
static const uint8_t * ttf_get_glyph_bitmap_cb(const lv_font_t * font, uint32_t unicode_letter)
|
||||
{
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
const stbtt_fontinfo * info = (const stbtt_fontinfo *)&dsc->info;
|
||||
int g1 = stbtt_FindGlyphIndex(info, (int)unicode_letter);
|
||||
if(g1 == 0) {
|
||||
/* Glyph not found */
|
||||
return NULL;
|
||||
}
|
||||
int x1, y1, x2, y2;
|
||||
stbtt_GetGlyphBitmapBox(info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
|
||||
int w, h;
|
||||
w = x2 - x1 + 1;
|
||||
h = y2 - y1 + 1;
|
||||
uint32_t stride = w;
|
||||
/*Try to load from cache*/
|
||||
ttf_bitmap_cache_key_t cache_key;
|
||||
lv_memset(&cache_key, 0, sizeof(cache_key)); /*Zero padding*/
|
||||
cache_key.unicode_letter = unicode_letter;
|
||||
cache_key.line_height = font->line_height;
|
||||
uint8_t * buffer = NULL;
|
||||
lv_lru_get(dsc->bitmap_cache, &cache_key, sizeof(cache_key), (void **)&buffer);
|
||||
if(buffer) {
|
||||
return buffer;
|
||||
}
|
||||
LV_LOG_TRACE("cache miss for letter: %u", unicode_letter);
|
||||
/*Prepare space in cache*/
|
||||
size_t szb = h * stride;
|
||||
buffer = lv_mem_alloc(szb);
|
||||
if(!buffer) {
|
||||
LV_LOG_ERROR("failed to allocate cache value");
|
||||
return NULL;
|
||||
}
|
||||
lv_memset(buffer, 0, szb);
|
||||
if(LV_LRU_OK != lv_lru_set(dsc->bitmap_cache, &cache_key, sizeof(cache_key), buffer, szb)) {
|
||||
LV_LOG_ERROR("failed to add cache value");
|
||||
lv_mem_free(buffer);
|
||||
return NULL;
|
||||
}
|
||||
/*Render into cache*/
|
||||
stbtt_MakeGlyphBitmap(info, buffer, w, h, stride, dsc->scale, dsc->scale, g1);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static lv_font_t * lv_tiny_ttf_create(const char * path, const void * data, size_t data_size, lv_coord_t font_size,
|
||||
size_t cache_size)
|
||||
{
|
||||
if((path == NULL && data == NULL) || 0 >= font_size) {
|
||||
LV_LOG_ERROR("tiny_ttf: invalid argument\n");
|
||||
return NULL;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)TTF_MALLOC(sizeof(ttf_font_desc_t));
|
||||
if(dsc == NULL) {
|
||||
LV_LOG_ERROR("tiny_ttf: out of memory\n");
|
||||
return NULL;
|
||||
}
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
if(path != NULL) {
|
||||
if(LV_FS_RES_OK != lv_fs_open(&dsc->file, path, LV_FS_MODE_RD)) {
|
||||
LV_LOG_ERROR("tiny_ttf: unable to open %s\n", path);
|
||||
goto err_after_dsc;
|
||||
}
|
||||
dsc->stream.file = &dsc->file;
|
||||
}
|
||||
else {
|
||||
dsc->stream.file = NULL;
|
||||
dsc->stream.data = (const uint8_t *)data;
|
||||
dsc->stream.size = data_size;
|
||||
dsc->stream.position = 0;
|
||||
}
|
||||
if(0 == stbtt_InitFont(&dsc->info, &dsc->stream, stbtt_GetFontOffsetForIndex(&dsc->stream, 0))) {
|
||||
LV_LOG_ERROR("tiny_ttf: init failed\n");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
|
||||
#else
|
||||
dsc->stream = (const uint8_t *)data;
|
||||
LV_UNUSED(data_size);
|
||||
if(0 == stbtt_InitFont(&dsc->info, dsc->stream, stbtt_GetFontOffsetForIndex(dsc->stream, 0))) {
|
||||
LV_LOG_ERROR("tiny_ttf: init failed\n");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
#endif
|
||||
|
||||
dsc->bitmap_cache = lv_lru_create(cache_size, font_size * font_size, lv_mem_free, lv_mem_free);
|
||||
if(dsc->bitmap_cache == NULL) {
|
||||
LV_LOG_ERROR("failed to create lru cache");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
|
||||
lv_font_t * out_font = (lv_font_t *)TTF_MALLOC(sizeof(lv_font_t));
|
||||
if(out_font == NULL) {
|
||||
LV_LOG_ERROR("tiny_ttf: out of memory\n");
|
||||
goto err_after_bitmap_cache;
|
||||
}
|
||||
lv_memset(out_font, 0, sizeof(lv_font_t));
|
||||
out_font->get_glyph_dsc = ttf_get_glyph_dsc_cb;
|
||||
out_font->get_glyph_bitmap = ttf_get_glyph_bitmap_cb;
|
||||
out_font->dsc = dsc;
|
||||
lv_tiny_ttf_set_size(out_font, font_size);
|
||||
return out_font;
|
||||
err_after_bitmap_cache:
|
||||
lv_lru_del(dsc->bitmap_cache);
|
||||
err_after_dsc:
|
||||
TTF_FREE(dsc);
|
||||
return NULL;
|
||||
}
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size)
|
||||
{
|
||||
return lv_tiny_ttf_create(path, NULL, 0, font_size, cache_size);
|
||||
}
|
||||
lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size)
|
||||
{
|
||||
return lv_tiny_ttf_create_file_ex(path, font_size, 4096);
|
||||
}
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size)
|
||||
{
|
||||
return lv_tiny_ttf_create(NULL, data, data_size, font_size, cache_size);
|
||||
}
|
||||
lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size)
|
||||
{
|
||||
return lv_tiny_ttf_create_data_ex(data, data_size, font_size, 4096);
|
||||
}
|
||||
void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size)
|
||||
{
|
||||
if(font_size <= 0) {
|
||||
LV_LOG_ERROR("invalid font size: %"PRIx32, font_size);
|
||||
return;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
dsc->scale = stbtt_ScaleForMappingEmToPixels(&dsc->info, font_size);
|
||||
int line_gap = 0;
|
||||
stbtt_GetFontVMetrics(&dsc->info, &dsc->ascent, &dsc->descent, &line_gap);
|
||||
font->line_height = (lv_coord_t)(dsc->scale * (dsc->ascent - dsc->descent + line_gap));
|
||||
font->base_line = (lv_coord_t)(dsc->scale * (line_gap - dsc->descent));
|
||||
}
|
||||
void lv_tiny_ttf_destroy(lv_font_t * font)
|
||||
{
|
||||
if(font != NULL) {
|
||||
if(font->dsc != NULL) {
|
||||
ttf_font_desc_t * ttf = (ttf_font_desc_t *)font->dsc;
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
if(ttf->stream.file != NULL) {
|
||||
lv_fs_close(&ttf->file);
|
||||
}
|
||||
#endif
|
||||
lv_lru_del(ttf->bitmap_cache);
|
||||
TTF_FREE(ttf);
|
||||
}
|
||||
TTF_FREE(font);
|
||||
}
|
||||
}
|
||||
#endif /*LV_USE_TINY_TTF*/
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
/**
|
||||
* @file lv_tiny_ttf.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_TINY_TTF_H
|
||||
#define LV_TINY_TTF_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_TINY_TTF
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
/* create a font from the specified file or path with the specified line height.*/
|
||||
lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size);
|
||||
|
||||
/* create a font from the specified file or path with the specified line height with the specified cache size.*/
|
||||
lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size);
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
|
||||
/* create a font from the specified data pointer with the specified line height.*/
|
||||
lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size);
|
||||
|
||||
/* create a font from the specified data pointer with the specified line height and the specified cache size.*/
|
||||
lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size);
|
||||
|
||||
/* set the size of the font to a new font_size*/
|
||||
void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size);
|
||||
|
||||
/* destroy a font previously created with lv_tiny_ttf_create_xxxx()*/
|
||||
void lv_tiny_ttf_destroy(lv_font_t * font);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_TINY_TTF*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /*extern "C"*/
|
||||
#endif
|
||||
|
||||
#endif /*LV_TINY_TTF_H*/
|
||||
|
|
@ -0,0 +1,637 @@
|
|||
// stb_rect_pack.h - v1.01 - public domain - rectangle packing
|
||||
// Sean Barrett 2014
|
||||
//
|
||||
// Useful for e.g. packing rectangular textures into an atlas.
|
||||
// Does not do rotation.
|
||||
//
|
||||
// Before #including,
|
||||
//
|
||||
// #define STB_RECT_PACK_IMPLEMENTATION
|
||||
//
|
||||
// in the file that you want to have the implementation.
|
||||
//
|
||||
// Not necessarily the awesomest packing method, but better than
|
||||
// the totally naive one in stb_truetype (which is primarily what
|
||||
// this is meant to replace).
|
||||
//
|
||||
// Has only had a few tests run, may have issues.
|
||||
//
|
||||
// More docs to come.
|
||||
//
|
||||
// No memory allocations; uses qsort() and assert() from stdlib.
|
||||
// Can override those by defining STBRP_SORT and STBRP_ASSERT.
|
||||
//
|
||||
// This library currently uses the Skyline Bottom-Left algorithm.
|
||||
//
|
||||
// Please note: better rectangle packers are welcome! Please
|
||||
// implement them to the same API, but with a different init
|
||||
// function.
|
||||
//
|
||||
// Credits
|
||||
//
|
||||
// Library
|
||||
// Sean Barrett
|
||||
// Minor features
|
||||
// Martins Mozeiko
|
||||
// github:IntellectualKitty
|
||||
//
|
||||
// Bugfixes / warning fixes
|
||||
// Jeremy Jaussaud
|
||||
// Fabian Giesen
|
||||
//
|
||||
// Version history:
|
||||
//
|
||||
// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section
|
||||
// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles
|
||||
// 0.99 (2019-02-07) warning fixes
|
||||
// 0.11 (2017-03-03) return packing success/fail result
|
||||
// 0.10 (2016-10-25) remove cast-away-const to avoid warnings
|
||||
// 0.09 (2016-08-27) fix compiler warnings
|
||||
// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0)
|
||||
// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0)
|
||||
// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort
|
||||
// 0.05: added STBRP_ASSERT to allow replacing assert
|
||||
// 0.04: fixed minor bug in STBRP_LARGE_RECTS support
|
||||
// 0.01: initial release
|
||||
//
|
||||
// LICENSE
|
||||
//
|
||||
// See end of file for license information.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// INCLUDE SECTION
|
||||
//
|
||||
|
||||
#ifndef STB_INCLUDE_STB_RECT_PACK_H
|
||||
#define STB_INCLUDE_STB_RECT_PACK_H
|
||||
|
||||
#define STB_RECT_PACK_VERSION 1
|
||||
|
||||
#ifdef STBRP_STATIC
|
||||
#define STBRP_DEF static
|
||||
#else
|
||||
#define STBRP_DEF extern
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/// @cond
|
||||
/**
|
||||
* Tells Doxygen to ignore a duplicate declaration
|
||||
*/
|
||||
typedef struct stbrp_context stbrp_context;
|
||||
typedef struct stbrp_node stbrp_node;
|
||||
typedef struct stbrp_rect stbrp_rect;
|
||||
/// @endcond
|
||||
|
||||
typedef int stbrp_coord;
|
||||
|
||||
#define STBRP__MAXVAL 0x7fffffff
|
||||
// Mostly for internal use, but this is the maximum supported coordinate value.
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects);
|
||||
// Assign packed locations to rectangles. The rectangles are of type
|
||||
// 'stbrp_rect' defined below, stored in the array 'rects', and there
|
||||
// are 'num_rects' many of them.
|
||||
//
|
||||
// Rectangles which are successfully packed have the 'was_packed' flag
|
||||
// set to a non-zero value and 'x' and 'y' store the minimum location
|
||||
// on each axis (i.e. bottom-left in cartesian coordinates, top-left
|
||||
// if you imagine y increasing downwards). Rectangles which do not fit
|
||||
// have the 'was_packed' flag set to 0.
|
||||
//
|
||||
// You should not try to access the 'rects' array from another thread
|
||||
// while this function is running, as the function temporarily reorders
|
||||
// the array while it executes.
|
||||
//
|
||||
// To pack into another rectangle, you need to call stbrp_init_target
|
||||
// again. To continue packing into the same rectangle, you can call
|
||||
// this function again. Calling this multiple times with multiple rect
|
||||
// arrays will probably produce worse packing results than calling it
|
||||
// a single time with the full rectangle array, but the option is
|
||||
// available.
|
||||
//
|
||||
// The function returns 1 if all of the rectangles were successfully
|
||||
// packed and 0 otherwise.
|
||||
|
||||
struct stbrp_rect {
|
||||
// reserved for your use:
|
||||
int id;
|
||||
|
||||
// input:
|
||||
stbrp_coord w, h;
|
||||
|
||||
// output:
|
||||
stbrp_coord x, y;
|
||||
int was_packed; // non-zero if valid packing
|
||||
|
||||
}; // 16 bytes, nominally
|
||||
|
||||
|
||||
STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes);
|
||||
// Initialize a rectangle packer to:
|
||||
// pack a rectangle that is 'width' by 'height' in dimensions
|
||||
// using temporary storage provided by the array 'nodes', which is 'num_nodes' long
|
||||
//
|
||||
// You must call this function every time you start packing into a new target.
|
||||
//
|
||||
// There is no "shutdown" function. The 'nodes' memory must stay valid for
|
||||
// the following stbrp_pack_rects() call (or calls), but can be freed after
|
||||
// the call (or calls) finish.
|
||||
//
|
||||
// Note: to guarantee best results, either:
|
||||
// 1. make sure 'num_nodes' >= 'width'
|
||||
// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
|
||||
//
|
||||
// If you don't do either of the above things, widths will be quantized to multiples
|
||||
// of small integers to guarantee the algorithm doesn't run out of temporary storage.
|
||||
//
|
||||
// If you do #2, then the non-quantized algorithm will be used, but the algorithm
|
||||
// may run out of temporary storage and be unable to pack some rectangles.
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem);
|
||||
// Optionally call this function after init but before doing any packing to
|
||||
// change the handling of the out-of-temp-memory scenario, described above.
|
||||
// If you call init again, this will be reset to the default (false).
|
||||
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic);
|
||||
// Optionally select which packing heuristic the library should use. Different
|
||||
// heuristics will produce better/worse results for different data sets.
|
||||
// If you call init again, this will be reset to the default.
|
||||
|
||||
enum {
|
||||
STBRP_HEURISTIC_Skyline_default = 0,
|
||||
STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
|
||||
STBRP_HEURISTIC_Skyline_BF_sortHeight
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// the details of the following structures don't matter to you, but they must
|
||||
// be visible so you can handle the memory allocations for them
|
||||
|
||||
struct stbrp_node {
|
||||
stbrp_coord x, y;
|
||||
stbrp_node * next;
|
||||
};
|
||||
|
||||
struct stbrp_context {
|
||||
int width;
|
||||
int height;
|
||||
int align;
|
||||
int init_mode;
|
||||
int heuristic;
|
||||
int num_nodes;
|
||||
stbrp_node * active_head;
|
||||
stbrp_node * free_head;
|
||||
stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPLEMENTATION SECTION
|
||||
//
|
||||
|
||||
#ifdef STB_RECT_PACK_IMPLEMENTATION
|
||||
#ifndef STBRP_SORT
|
||||
#include <stdlib.h>
|
||||
#define STBRP_SORT qsort
|
||||
#endif
|
||||
|
||||
#ifndef STBRP_ASSERT
|
||||
#include <assert.h>
|
||||
#define STBRP_ASSERT assert
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define STBRP__NOTUSED(v) (void)(v)
|
||||
#define STBRP__CDECL __cdecl
|
||||
#else
|
||||
#define STBRP__NOTUSED(v) (void)sizeof(v)
|
||||
#define STBRP__CDECL
|
||||
#endif
|
||||
|
||||
enum {
|
||||
STBRP__INIT_skyline = 1
|
||||
};
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic)
|
||||
{
|
||||
switch(context->init_mode) {
|
||||
case STBRP__INIT_skyline:
|
||||
STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
|
||||
context->heuristic = heuristic;
|
||||
break;
|
||||
default:
|
||||
STBRP_ASSERT(0);
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem)
|
||||
{
|
||||
if(allow_out_of_mem)
|
||||
// if it's ok to run out of memory, then don't bother aligning them;
|
||||
// this gives better packing, but may fail due to OOM (even though
|
||||
// the rectangles easily fit). @TODO a smarter approach would be to only
|
||||
// quantize once we've hit OOM, then we could get rid of this parameter.
|
||||
context->align = 1;
|
||||
else {
|
||||
// if it's not ok to run out of memory, then quantize the widths
|
||||
// so that num_nodes is always enough nodes.
|
||||
//
|
||||
// I.e. num_nodes * align >= width
|
||||
// align >= width / num_nodes
|
||||
// align = ceil(width/num_nodes)
|
||||
|
||||
context->align = (context->width + context->num_nodes - 1) / context->num_nodes;
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i = 0; i < num_nodes - 1; ++i)
|
||||
nodes[i].next = &nodes[i + 1];
|
||||
nodes[i].next = NULL;
|
||||
context->init_mode = STBRP__INIT_skyline;
|
||||
context->heuristic = STBRP_HEURISTIC_Skyline_default;
|
||||
context->free_head = &nodes[0];
|
||||
context->active_head = &context->extra[0];
|
||||
context->width = width;
|
||||
context->height = height;
|
||||
context->num_nodes = num_nodes;
|
||||
stbrp_setup_allow_out_of_mem(context, 0);
|
||||
|
||||
// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
|
||||
context->extra[0].x = 0;
|
||||
context->extra[0].y = 0;
|
||||
context->extra[0].next = &context->extra[1];
|
||||
context->extra[1].x = (stbrp_coord) width;
|
||||
context->extra[1].y = (1 << 30);
|
||||
context->extra[1].next = NULL;
|
||||
}
|
||||
|
||||
// find minimum y position if it starts at x1
|
||||
static int stbrp__skyline_find_min_y(stbrp_context * c, stbrp_node * first, int x0, int width, int * pwaste)
|
||||
{
|
||||
stbrp_node * node = first;
|
||||
int x1 = x0 + width;
|
||||
int min_y, visited_width, waste_area;
|
||||
|
||||
STBRP__NOTUSED(c);
|
||||
|
||||
STBRP_ASSERT(first->x <= x0);
|
||||
|
||||
#if 0
|
||||
// skip in case we're past the node
|
||||
while(node->next->x <= x0)
|
||||
++node;
|
||||
#else
|
||||
STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
|
||||
#endif
|
||||
|
||||
STBRP_ASSERT(node->x <= x0);
|
||||
|
||||
min_y = 0;
|
||||
waste_area = 0;
|
||||
visited_width = 0;
|
||||
while(node->x < x1) {
|
||||
if(node->y > min_y) {
|
||||
// raise min_y higher.
|
||||
// we've accounted for all waste up to min_y,
|
||||
// but we'll now add more waste for everything we've visited
|
||||
waste_area += visited_width * (node->y - min_y);
|
||||
min_y = node->y;
|
||||
// the first time through, visited_width might be reduced
|
||||
if(node->x < x0)
|
||||
visited_width += node->next->x - x0;
|
||||
else
|
||||
visited_width += node->next->x - node->x;
|
||||
}
|
||||
else {
|
||||
// add waste area
|
||||
int under_width = node->next->x - node->x;
|
||||
if(under_width + visited_width > width)
|
||||
under_width = width - visited_width;
|
||||
waste_area += under_width * (min_y - node->y);
|
||||
visited_width += under_width;
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
*pwaste = waste_area;
|
||||
return min_y;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
stbrp_node ** prev_link;
|
||||
} stbrp__findresult;
|
||||
|
||||
static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context * c, int width, int height)
|
||||
{
|
||||
int best_waste = (1 << 30), best_x, best_y = (1 << 30);
|
||||
stbrp__findresult fr;
|
||||
stbrp_node ** prev, * node, * tail, ** best = NULL;
|
||||
|
||||
// align to multiple of c->align
|
||||
width = (width + c->align - 1);
|
||||
width -= width % c->align;
|
||||
STBRP_ASSERT(width % c->align == 0);
|
||||
|
||||
// if it can't possibly fit, bail immediately
|
||||
if(width > c->width || height > c->height) {
|
||||
fr.prev_link = NULL;
|
||||
fr.x = fr.y = 0;
|
||||
return fr;
|
||||
}
|
||||
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
while(node->x + width <= c->width) {
|
||||
int y, waste;
|
||||
y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
|
||||
if(c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
|
||||
// bottom left
|
||||
if(y < best_y) {
|
||||
best_y = y;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// best-fit
|
||||
if(y + height <= c->height) {
|
||||
// can only use it if it first vertically
|
||||
if(y < best_y || (y == best_y && waste < best_waste)) {
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
best_x = (best == NULL) ? 0 : (*best)->x;
|
||||
|
||||
// if doing best-fit (BF), we also have to try aligning right edge to each node position
|
||||
//
|
||||
// e.g, if fitting
|
||||
//
|
||||
// ____________________
|
||||
// |____________________|
|
||||
//
|
||||
// into
|
||||
//
|
||||
// | |
|
||||
// | ____________|
|
||||
// |____________|
|
||||
//
|
||||
// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
|
||||
//
|
||||
// This makes BF take about 2x the time
|
||||
|
||||
if(c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
|
||||
tail = c->active_head;
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
// find first node that's admissible
|
||||
while(tail->x < width)
|
||||
tail = tail->next;
|
||||
while(tail) {
|
||||
int xpos = tail->x - width;
|
||||
int y, waste;
|
||||
STBRP_ASSERT(xpos >= 0);
|
||||
// find the left position that matches this
|
||||
while(node->next->x <= xpos) {
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
|
||||
y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
|
||||
if(y + height <= c->height) {
|
||||
if(y <= best_y) {
|
||||
if(y < best_y || waste < best_waste || (waste == best_waste && xpos < best_x)) {
|
||||
best_x = xpos;
|
||||
STBRP_ASSERT(y <= best_y);
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
tail = tail->next;
|
||||
}
|
||||
}
|
||||
|
||||
fr.prev_link = best;
|
||||
fr.x = best_x;
|
||||
fr.y = best_y;
|
||||
return fr;
|
||||
}
|
||||
|
||||
static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context * context, int width, int height)
|
||||
{
|
||||
// find best position according to heuristic
|
||||
stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
|
||||
stbrp_node * node, * cur;
|
||||
|
||||
// bail if:
|
||||
// 1. it failed
|
||||
// 2. the best node doesn't fit (we don't always check this)
|
||||
// 3. we're out of memory
|
||||
if(res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
|
||||
res.prev_link = NULL;
|
||||
return res;
|
||||
}
|
||||
|
||||
// on success, create new node
|
||||
node = context->free_head;
|
||||
node->x = (stbrp_coord) res.x;
|
||||
node->y = (stbrp_coord)(res.y + height);
|
||||
|
||||
context->free_head = node->next;
|
||||
|
||||
// insert the new node into the right starting point, and
|
||||
// let 'cur' point to the remaining nodes needing to be
|
||||
// stiched back in
|
||||
|
||||
cur = *res.prev_link;
|
||||
if(cur->x < res.x) {
|
||||
// preserve the existing one, so start testing with the next one
|
||||
stbrp_node * next = cur->next;
|
||||
cur->next = node;
|
||||
cur = next;
|
||||
}
|
||||
else {
|
||||
*res.prev_link = node;
|
||||
}
|
||||
|
||||
// from here, traverse cur and free the nodes, until we get to one
|
||||
// that shouldn't be freed
|
||||
while(cur->next && cur->next->x <= res.x + width) {
|
||||
stbrp_node * next = cur->next;
|
||||
// move the current node to the free list
|
||||
cur->next = context->free_head;
|
||||
context->free_head = cur;
|
||||
cur = next;
|
||||
}
|
||||
|
||||
// stitch the list back in
|
||||
node->next = cur;
|
||||
|
||||
if(cur->x < res.x + width)
|
||||
cur->x = (stbrp_coord)(res.x + width);
|
||||
|
||||
#ifdef _DEBUG
|
||||
cur = context->active_head;
|
||||
while(cur->x < context->width) {
|
||||
STBRP_ASSERT(cur->x < cur->next->x);
|
||||
cur = cur->next;
|
||||
}
|
||||
STBRP_ASSERT(cur->next == NULL);
|
||||
|
||||
{
|
||||
int count = 0;
|
||||
cur = context->active_head;
|
||||
while(cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
cur = context->free_head;
|
||||
while(cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
STBRP_ASSERT(count == context->num_nodes + 2);
|
||||
}
|
||||
#endif
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_height_compare(const void * a, const void * b)
|
||||
{
|
||||
const stbrp_rect * p = (const stbrp_rect *) a;
|
||||
const stbrp_rect * q = (const stbrp_rect *) b;
|
||||
if(p->h > q->h)
|
||||
return -1;
|
||||
if(p->h < q->h)
|
||||
return 1;
|
||||
return (p->w > q->w) ? -1 : (p->w < q->w);
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_original_order(const void * a, const void * b)
|
||||
{
|
||||
const stbrp_rect * p = (const stbrp_rect *) a;
|
||||
const stbrp_rect * q = (const stbrp_rect *) b;
|
||||
return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
|
||||
}
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects)
|
||||
{
|
||||
int i, all_rects_packed = 1;
|
||||
|
||||
// we use the 'was_packed' field internally to allow sorting/unsorting
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = i;
|
||||
}
|
||||
|
||||
// sort according to heuristic
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
|
||||
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
if(rects[i].w == 0 || rects[i].h == 0) {
|
||||
rects[i].x = rects[i].y = 0; // empty rect needs no space
|
||||
}
|
||||
else {
|
||||
stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
|
||||
if(fr.prev_link) {
|
||||
rects[i].x = (stbrp_coord) fr.x;
|
||||
rects[i].y = (stbrp_coord) fr.y;
|
||||
}
|
||||
else {
|
||||
rects[i].x = rects[i].y = STBRP__MAXVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// unsort
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
|
||||
|
||||
// set was_packed flags and all_rects_packed status
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
|
||||
if(!rects[i].was_packed)
|
||||
all_rects_packed = 0;
|
||||
}
|
||||
|
||||
// return the all_rects_packed status
|
||||
return all_rects_packed;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------
|
||||
This software is available under 2 licenses -- choose whichever you prefer.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE A - MIT License
|
||||
Copyright (c) 2017 Sean Barrett
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
||||
This is free and unencumbered software released into the public domain.
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
commercial or non-commercial, and by any means.
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
this software under copyright law.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -50,6 +50,10 @@ void lv_extra_init(void)
|
|||
lv_fs_fatfs_init();
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_LITTLEFS != '\0'
|
||||
lv_fs_littlefs_init();
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_STDIO != '\0'
|
||||
lv_fs_stdio_init();
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -562,6 +562,8 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t *
|
|||
lv_memset_00(pinyin_ime->py_num, sizeof(pinyin_ime->py_num));
|
||||
lv_memset_00(pinyin_ime->py_pos, sizeof(pinyin_ime->py_pos));
|
||||
|
||||
lv_obj_add_flag(obj, LV_OBJ_FLAG_HIDDEN);
|
||||
|
||||
lv_obj_set_size(obj, LV_PCT(100), LV_PCT(55));
|
||||
lv_obj_align(obj, LV_ALIGN_BOTTOM_MID, 0, 0);
|
||||
|
||||
|
|
@ -576,6 +578,7 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t *
|
|||
lv_obj_add_flag(pinyin_ime->cand_panel, LV_OBJ_FLAG_HIDDEN);
|
||||
|
||||
lv_btnmatrix_set_one_checked(pinyin_ime->cand_panel, true);
|
||||
lv_obj_clear_flag(pinyin_ime->cand_panel, LV_OBJ_FLAG_CLICK_FOCUSABLE);
|
||||
|
||||
/* Set cand_panel style*/
|
||||
// Default style
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ static const lv_btnmatrix_ctrl_t default_kb_ctrl_uc_map[] = {
|
|||
};
|
||||
|
||||
static const char * const default_kb_map_spec[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", LV_SYMBOL_BACKSPACE, "\n",
|
||||
"abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
|
||||
"abc", "+", "&", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
|
||||
"\\", "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
|
||||
LV_SYMBOL_KEYBOARD, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
|
||||
};
|
||||
|
|
|
|||
|
|
@ -360,6 +360,8 @@ static void draw_arcs(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area_t
|
|||
int32_t end_angle = lv_map(indic->end_value, scale->min, scale->max, scale->rotation,
|
||||
scale->rotation + scale->angle_range);
|
||||
|
||||
arc_dsc.start_angle = start_angle;
|
||||
arc_dsc.end_angle = end_angle;
|
||||
part_draw_dsc.radius = r_out + indic->type_data.arc.r_mod;
|
||||
part_draw_dsc.sub_part_ptr = indic;
|
||||
part_draw_dsc.p1 = &scale_center;
|
||||
|
|
@ -511,7 +513,8 @@ static void draw_ticks_and_labels(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, cons
|
|||
lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
|
||||
|
||||
lv_point_t label_size;
|
||||
lv_txt_get_size(&label_size, part_draw_dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
|
||||
lv_txt_get_size(&label_size, part_draw_dsc.text, label_dsc_tmp.font, label_dsc_tmp.letter_space,
|
||||
label_dsc_tmp.line_space,
|
||||
LV_COORD_MAX, LV_TEXT_FLAG_NONE);
|
||||
|
||||
lv_area_t label_cord;
|
||||
|
|
@ -569,6 +572,7 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
|
|||
lv_obj_draw_dsc_init(&part_draw_dsc, draw_ctx);
|
||||
part_draw_dsc.class_p = MY_CLASS;
|
||||
part_draw_dsc.p1 = &scale_center;
|
||||
part_draw_dsc.part = LV_PART_INDICATOR;
|
||||
|
||||
lv_meter_indicator_t * indic;
|
||||
_LV_LL_READ_BACK(&meter->indicator_ll, indic) {
|
||||
|
|
@ -585,12 +589,12 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
|
|||
line_dsc.width = indic->type_data.needle_line.width;
|
||||
line_dsc.opa = indic->opa > LV_OPA_MAX ? opa_main : (opa_main * indic->opa) >> 8;
|
||||
|
||||
part_draw_dsc.id = LV_METER_DRAW_PART_NEEDLE_LINE;
|
||||
part_draw_dsc.type = LV_METER_DRAW_PART_NEEDLE_LINE;
|
||||
part_draw_dsc.line_dsc = &line_dsc;
|
||||
part_draw_dsc.p2 = &p_end;
|
||||
|
||||
part_draw_dsc.p1 = &scale_center;
|
||||
lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
|
||||
lv_draw_line(draw_ctx, &line_dsc, &scale_center, &p_end);
|
||||
lv_draw_line(draw_ctx, &line_dsc, part_draw_dsc.p1, &p_end);
|
||||
lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
|
||||
}
|
||||
else if(indic->type == LV_METER_INDICATOR_TYPE_NEEDLE_IMG) {
|
||||
|
|
@ -612,7 +616,7 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
|
|||
if(angle > 3600) angle -= 3600;
|
||||
img_dsc.angle = angle;
|
||||
|
||||
part_draw_dsc.id = LV_METER_DRAW_PART_NEEDLE_IMG;
|
||||
part_draw_dsc.type = LV_METER_DRAW_PART_NEEDLE_IMG;
|
||||
part_draw_dsc.img_dsc = &img_dsc;
|
||||
|
||||
lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@ typedef struct {
|
|||
uint16_t tick_major_width;
|
||||
|
||||
int16_t label_gap;
|
||||
int16_t label_color;
|
||||
|
||||
int32_t min;
|
||||
int32_t max;
|
||||
|
|
|
|||
|
|
@ -2099,6 +2099,31 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/
|
||||
#ifndef LV_USE_FS_LITTLEFS
|
||||
#ifdef CONFIG_LV_USE_FS_LITTLEFS
|
||||
#define LV_USE_FS_LITTLEFS CONFIG_LV_USE_FS_LITTLEFS
|
||||
#else
|
||||
#define LV_USE_FS_LITTLEFS 0
|
||||
#endif
|
||||
#endif
|
||||
#if LV_USE_FS_LITTLEFS
|
||||
#ifndef LV_FS_LITTLEFS_LETTER
|
||||
#ifdef CONFIG_LV_FS_LITTLEFS_LETTER
|
||||
#define LV_FS_LITTLEFS_LETTER CONFIG_LV_FS_LITTLEFS_LETTER
|
||||
#else
|
||||
#define LV_FS_LITTLEFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
|
||||
#endif
|
||||
#endif
|
||||
#ifndef LV_FS_LITTLEFS_CACHE_SIZE
|
||||
#ifdef CONFIG_LV_FS_LITTLEFS_CACHE_SIZE
|
||||
#define LV_FS_LITTLEFS_CACHE_SIZE CONFIG_LV_FS_LITTLEFS_CACHE_SIZE
|
||||
#else
|
||||
#define LV_FS_LITTLEFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*PNG decoder library*/
|
||||
#ifndef LV_USE_PNG
|
||||
#ifdef CONFIG_LV_USE_PNG
|
||||
|
|
@ -2192,6 +2217,25 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
/*Tiny TTF library*/
|
||||
#ifndef LV_USE_TINY_TTF
|
||||
#ifdef CONFIG_LV_USE_TINY_TTF
|
||||
#define LV_USE_TINY_TTF CONFIG_LV_USE_TINY_TTF
|
||||
#else
|
||||
#define LV_USE_TINY_TTF 0
|
||||
#endif
|
||||
#endif
|
||||
#if LV_USE_TINY_TTF
|
||||
/*Load TTF data from files*/
|
||||
#ifndef LV_TINY_TTF_FILE_SUPPORT
|
||||
#ifdef CONFIG_LV_TINY_TTF_FILE_SUPPORT
|
||||
#define LV_TINY_TTF_FILE_SUPPORT CONFIG_LV_TINY_TTF_FILE_SUPPORT
|
||||
#else
|
||||
#define LV_TINY_TTF_FILE_SUPPORT 0
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*Rlottie library*/
|
||||
#ifndef LV_USE_RLOTTIE
|
||||
#ifdef CONFIG_LV_USE_RLOTTIE
|
||||
|
|
|
|||
|
|
@ -57,7 +57,6 @@ enum {
|
|||
};
|
||||
typedef uint8_t lv_fs_mode_t;
|
||||
|
||||
|
||||
/**
|
||||
* Seek modes.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -40,14 +40,20 @@
|
|||
/* platform-specific printf format for int32_t, usually "d" or "ld" */
|
||||
#define LV_PRId32 PRId32
|
||||
#define LV_PRIu32 PRIu32
|
||||
#define LV_PRIx32 PRIx32
|
||||
#define LV_PRIX32 PRIX32
|
||||
#else
|
||||
#define LV_PRId32 "d"
|
||||
#define LV_PRIu32 "u"
|
||||
#define LV_PRIx32 "x"
|
||||
#define LV_PRIX32 "X"
|
||||
#endif
|
||||
#else
|
||||
/* hope this is correct for ports without __has_include or without inttypes.h */
|
||||
#define LV_PRId32 "d"
|
||||
#define LV_PRIu32 "u"
|
||||
#define LV_PRIx32 "x"
|
||||
#define LV_PRIX32 "X"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -21,6 +21,10 @@
|
|||
#define MY_CLASS &lv_arc_class
|
||||
|
||||
#define VALUE_UNSET INT16_MIN
|
||||
#define CLICK_OUTSIDE_BG_ANGLES ((uint32_t) 0x00U)
|
||||
#define CLICK_INSIDE_BG_ANGLES ((uint32_t) 0x01U)
|
||||
#define CLICK_CLOSER_TO_MAX_END ((uint32_t) 0x00U)
|
||||
#define CLICK_CLOSER_TO_MIN_END ((uint32_t) 0x01U)
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
|
|
@ -40,6 +44,7 @@ static lv_coord_t get_angle(const lv_obj_t * obj);
|
|||
static void get_knob_area(lv_obj_t * arc, const lv_point_t * center, lv_coord_t r, lv_area_t * knob_area);
|
||||
static void value_update(lv_obj_t * arc);
|
||||
static lv_coord_t knob_get_extra_size(lv_obj_t * obj);
|
||||
static bool lv_arc_angle_within_bg_bounds(lv_obj_t * obj, const uint32_t angle, const uint32_t tolerance_deg);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
|
|
@ -399,6 +404,7 @@ static void lv_arc_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
|||
arc->chg_rate = 720;
|
||||
arc->last_tick = lv_tick_get();
|
||||
arc->last_angle = arc->indic_angle_end;
|
||||
arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
|
||||
|
||||
lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
|
||||
lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLL_CHAIN | LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
|
@ -478,29 +484,54 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
|
|||
angle -= arc->rotation;
|
||||
angle -= arc->bg_angle_start; /*Make the angle relative to the start angle*/
|
||||
|
||||
/* If we click near the bg_angle_start the angle will be close to 360° instead of an small angle */
|
||||
if(angle < 0) angle += 360;
|
||||
|
||||
int16_t deg_range = bg_end - arc->bg_angle_start;
|
||||
const uint32_t circumference = (uint32_t)((2U * r * 314U) / 100U); /* Equivalent to: 2r * 3.14, avoiding floats */
|
||||
const uint32_t tolerance_deg = (360U * LV_DPX(50U)) / circumference;
|
||||
const uint32_t min_close_prev = (uint32_t) arc->min_close;
|
||||
|
||||
const bool is_angle_within_bg_bounds = lv_arc_angle_within_bg_bounds(obj, (uint32_t) angle, tolerance_deg);
|
||||
if(!is_angle_within_bg_bounds) {
|
||||
return;
|
||||
}
|
||||
|
||||
int16_t deg_range = bg_end - arc->bg_angle_start;
|
||||
int16_t last_angle_rel = arc->last_angle - arc->bg_angle_start;
|
||||
int16_t delta_angle = angle - last_angle_rel;
|
||||
|
||||
/*Do not allow big jumps.
|
||||
/*Do not allow big jumps (jumps bigger than 280°).
|
||||
*It's mainly to avoid jumping to the opposite end if the "dead" range between min. and max. is crossed.
|
||||
*Check which end was closer on the last valid press (arc->min_close) and prefer that end*/
|
||||
if(LV_ABS(delta_angle) > 280) {
|
||||
if(arc->min_close) angle = 0;
|
||||
else angle = deg_range;
|
||||
}
|
||||
else {
|
||||
if(angle < deg_range / 2)arc->min_close = 1;
|
||||
else arc->min_close = 0;
|
||||
/* Check if click was outside the background arc start and end angles */
|
||||
else if(CLICK_OUTSIDE_BG_ANGLES == arc->in_out) {
|
||||
if(arc->min_close) angle = -deg_range;
|
||||
else angle = deg_range;
|
||||
}
|
||||
else { /* Keep the angle value */ }
|
||||
|
||||
/* Prevent big jumps when the click goes from start to end angle in the invisible
|
||||
* part of the background arc without being released */
|
||||
if(((min_close_prev == CLICK_CLOSER_TO_MIN_END) && (arc->min_close == CLICK_CLOSER_TO_MAX_END))
|
||||
&& ((CLICK_OUTSIDE_BG_ANGLES == arc->in_out) && (LV_ABS(delta_angle) > 280))) {
|
||||
angle = 0;
|
||||
}
|
||||
else if(((min_close_prev == CLICK_CLOSER_TO_MAX_END) && (arc->min_close == CLICK_CLOSER_TO_MIN_END))
|
||||
&& (CLICK_OUTSIDE_BG_ANGLES == arc->in_out)) {
|
||||
angle = deg_range;
|
||||
}
|
||||
else { /* Keep the angle value */ }
|
||||
|
||||
/*Calculate the slew rate limited angle based on change rate (degrees/sec)*/
|
||||
delta_angle = angle - last_angle_rel;
|
||||
|
||||
uint32_t delta_tick = lv_tick_elaps(arc->last_tick);
|
||||
int16_t delta_angle_max = (arc->chg_rate * delta_tick) / 1000;
|
||||
/* delta_angle_max can never be signed. delta_tick is always signed, same for ch_rate */
|
||||
const uint16_t delta_angle_max = (arc->chg_rate * delta_tick) / 1000;
|
||||
|
||||
if(delta_angle > delta_angle_max) {
|
||||
delta_angle = delta_angle_max;
|
||||
|
|
@ -508,6 +539,7 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
|
|||
else if(delta_angle < -delta_angle_max) {
|
||||
delta_angle = -delta_angle_max;
|
||||
}
|
||||
else { /* Nothing to do */ }
|
||||
|
||||
angle = last_angle_rel + delta_angle; /*Apply the limited angle change*/
|
||||
|
||||
|
|
@ -564,7 +596,7 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
|
|||
}
|
||||
}
|
||||
else if(code == LV_EVENT_HIT_TEST) {
|
||||
lv_hit_test_info_t * info = lv_event_get_param(e);;
|
||||
lv_hit_test_info_t * info = lv_event_get_param(e);
|
||||
|
||||
lv_point_t p;
|
||||
lv_coord_t r;
|
||||
|
|
@ -868,4 +900,121 @@ static lv_coord_t knob_get_extra_size(lv_obj_t * obj)
|
|||
return LV_MAX(knob_shadow_size, knob_outline_size);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if angle is within arc background bounds
|
||||
*
|
||||
* In order to avoid unexpected value update of the arc value when the user clicks
|
||||
* outside of the arc background we need to check if the angle (of the clicked point)
|
||||
* is within the bounds of the background.
|
||||
*
|
||||
* A tolerance (extra room) also should be taken into consideration.
|
||||
*
|
||||
* E.g. Arc with start angle of 0° and end angle of 90°, the background is only visible in
|
||||
* that range, from 90° to 360° the background is invisible. Click in 150° should not update
|
||||
* the arc value, click within the arc angle range should.
|
||||
*
|
||||
* IMPORTANT NOTE: angle is always relative to bg_angle_start, e.g. if bg_angle_start is 30
|
||||
* and we click a bit to the left, angle is 10, not the expected 40.
|
||||
*
|
||||
* @param obj Pointer to lv_arc
|
||||
* @param angle Angle to be checked
|
||||
* @param tolerance_deg Tolerance
|
||||
*
|
||||
* @return true if angle is within arc background bounds, false otherwise
|
||||
*/
|
||||
static bool lv_arc_angle_within_bg_bounds(lv_obj_t * obj, const uint32_t angle, const uint32_t tolerance_deg)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
lv_arc_t * arc = (lv_arc_t *)obj;
|
||||
|
||||
uint32_t smaller_angle = 0;
|
||||
uint32_t bigger_angle = 0;
|
||||
|
||||
/* Determine which background angle is smaller and bigger */
|
||||
if(arc->bg_angle_start < arc->bg_angle_end) {
|
||||
bigger_angle = arc->bg_angle_end;
|
||||
smaller_angle = arc->bg_angle_start;
|
||||
}
|
||||
else {
|
||||
bigger_angle = (360 - arc->bg_angle_start) + arc->bg_angle_end;
|
||||
smaller_angle = 0;
|
||||
}
|
||||
|
||||
/* Angle is between both background angles */
|
||||
if((smaller_angle <= angle) && (angle <= bigger_angle)) {
|
||||
|
||||
if(((bigger_angle - smaller_angle) / 2U) >= angle) {
|
||||
arc->min_close = 1;
|
||||
}
|
||||
else {
|
||||
arc->min_close = 0;
|
||||
}
|
||||
|
||||
arc->in_out = CLICK_INSIDE_BG_ANGLES;
|
||||
|
||||
return true;
|
||||
}
|
||||
/* Distance between background start and end angles is less than tolerance,
|
||||
* consider the click inside the arc */
|
||||
else if(((smaller_angle - tolerance_deg) <= 0U) &&
|
||||
(360U - (bigger_angle + (smaller_angle - tolerance_deg)))) {
|
||||
|
||||
arc->min_close = 1;
|
||||
arc->in_out = CLICK_INSIDE_BG_ANGLES;
|
||||
return true;
|
||||
}
|
||||
else { /* Case handled below */ }
|
||||
|
||||
/* Legends:
|
||||
* 0° = angle 0
|
||||
* 360° = angle 360
|
||||
* T: Tolerance
|
||||
* A: Angle
|
||||
* S: Arc background start angle
|
||||
* E: Arc background end angle
|
||||
*
|
||||
* Start angle is bigger or equal to tolerance */
|
||||
if((smaller_angle >= tolerance_deg)
|
||||
/* (360° - T) --- A --- 360° */
|
||||
&& ((angle >= (360U - tolerance_deg)) && (angle <= 360U))) {
|
||||
|
||||
arc->min_close = 1;
|
||||
arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
|
||||
return true;
|
||||
}
|
||||
/* Tolerance is bigger than bg start angle */
|
||||
else if((smaller_angle < tolerance_deg)
|
||||
/* (360° - (T - S)) --- A --- 360° */
|
||||
&& (((360U - (tolerance_deg - smaller_angle)) <= angle)) && (angle <= 360U)) {
|
||||
|
||||
arc->min_close = 1;
|
||||
arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
|
||||
return true;
|
||||
}
|
||||
/* 360° is bigger than background end angle + tolerance */
|
||||
else if((360U >= (bigger_angle + tolerance_deg))
|
||||
/* E --- A --- (E + T) */
|
||||
&& ((bigger_angle <= (angle + smaller_angle)) &&
|
||||
((angle + smaller_angle) <= (bigger_angle + tolerance_deg)))) {
|
||||
|
||||
arc->min_close = 0;
|
||||
arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
|
||||
return true;
|
||||
}
|
||||
/* Background end angle + tolerance is bigger than 360° and bg_start_angle + tolerance is not near 0° + ((bg_end_angle + tolerance) - 360°)
|
||||
* Here we can assume background is not near 0° because of the first two initial checks */
|
||||
else if((360U < (bigger_angle + tolerance_deg))
|
||||
&& (angle <= 0U + ((bigger_angle + tolerance_deg) - 360U)) && (angle > bigger_angle)) {
|
||||
|
||||
arc->min_close = 0;
|
||||
arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
/* Nothing to do */
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -44,10 +44,11 @@ typedef struct {
|
|||
int16_t value; /*Current value of the arc*/
|
||||
int16_t min_value; /*Minimum value of the arc*/
|
||||
int16_t max_value; /*Maximum value of the arc*/
|
||||
uint16_t dragging : 1;
|
||||
uint16_t type : 2;
|
||||
uint16_t min_close : 1; /*1: the last pressed angle was closer to minimum end*/
|
||||
uint16_t chg_rate; /*Drag angle rate of change of the arc (degrees/sec)*/
|
||||
uint32_t dragging : 1;
|
||||
uint32_t type : 2;
|
||||
uint32_t min_close : 1; /*1: the last pressed angle was closer to minimum end*/
|
||||
uint32_t in_out : 1; /* 1: The click was within the background arc angles. 0: Click outside */
|
||||
uint32_t chg_rate; /*Drag angle rate of change of the arc (degrees/sec)*/
|
||||
uint32_t last_tick; /*Last dragging event timestamp of the arc*/
|
||||
int16_t last_angle; /*Last dragging angle of the arc*/
|
||||
} lv_arc_t;
|
||||
|
|
|
|||
|
|
@ -448,6 +448,9 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
|
|||
invalidate_button_area(obj, btnm->btn_id_sel); /*Invalidate the new area*/
|
||||
}
|
||||
}
|
||||
else {
|
||||
btnm->btn_id_sel = LV_BTNMATRIX_BTN_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
if(btnm->btn_id_sel != LV_BTNMATRIX_BTN_NONE) {
|
||||
|
|
|
|||
|
|
@ -74,14 +74,16 @@ void lv_checkbox_set_text(lv_obj_t * obj, const char * txt)
|
|||
size_t len = strlen(txt);
|
||||
#endif
|
||||
|
||||
if(!cb->static_txt) cb->txt = lv_mem_realloc(cb->txt, len + 1);
|
||||
else cb->txt = lv_mem_alloc(len + 1);
|
||||
char * _txt = (char *)cb->txt;
|
||||
if(!cb->static_txt) _txt = lv_mem_realloc(_txt, len + 1);
|
||||
else _txt = lv_mem_alloc(len + 1);
|
||||
#if LV_USE_ARABIC_PERSIAN_CHARS
|
||||
_lv_txt_ap_proc(txt, cb->txt);
|
||||
_lv_txt_ap_proc(txt, _txt);
|
||||
#else
|
||||
strcpy(cb->txt, txt);
|
||||
strcpy(_txt, txt);
|
||||
#endif
|
||||
|
||||
cb->txt = _txt;
|
||||
cb->static_txt = 0;
|
||||
|
||||
lv_obj_refresh_self_size(obj);
|
||||
|
|
@ -92,7 +94,7 @@ void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt)
|
|||
{
|
||||
lv_checkbox_t * cb = (lv_checkbox_t *)obj;
|
||||
|
||||
if(!cb->static_txt) lv_mem_free(cb->txt);
|
||||
if(!cb->static_txt) lv_mem_free((void *)cb->txt);
|
||||
|
||||
cb->txt = (char *)txt;
|
||||
cb->static_txt = 1;
|
||||
|
|
@ -138,7 +140,7 @@ static void lv_checkbox_destructor(const lv_obj_class_t * class_p, lv_obj_t * ob
|
|||
|
||||
lv_checkbox_t * cb = (lv_checkbox_t *)obj;
|
||||
if(!cb->static_txt) {
|
||||
lv_mem_free(cb->txt);
|
||||
lv_mem_free((void *)cb->txt);
|
||||
cb->txt = NULL;
|
||||
}
|
||||
LV_TRACE_OBJ_CREATE("finished");
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ extern "C" {
|
|||
|
||||
typedef struct {
|
||||
lv_obj_t obj;
|
||||
char * txt;
|
||||
const char * txt;
|
||||
uint32_t static_txt : 1;
|
||||
} lv_checkbox_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -407,14 +407,19 @@ int32_t lv_dropdown_get_option_index(lv_obj_t * obj, const char * option)
|
|||
const char * opts = lv_dropdown_get_options(obj);
|
||||
uint32_t char_i = 0;
|
||||
uint32_t opt_i = 0;
|
||||
uint32_t option_len = strlen(option);
|
||||
const char * start = opts;
|
||||
|
||||
while(start[char_i] != '\0') {
|
||||
for(char_i = 0; (start[char_i] != '\n') && (start[char_i] != '\0'); char_i++);
|
||||
|
||||
if(memcmp(start, option, LV_MIN(strlen(option), char_i)) == 0) return opt_i;
|
||||
if(option_len == char_i && memcmp(start, option, LV_MIN(option_len, char_i)) == 0) {
|
||||
return opt_i;
|
||||
}
|
||||
|
||||
start = &start[char_i];
|
||||
if(start[0] == '\n') start++;
|
||||
char_i = 0;
|
||||
opt_i++;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ static void refr_size_form_row(lv_obj_t * obj, uint32_t start_row);
|
|||
static void refr_cell_size(lv_obj_t * obj, uint32_t row, uint32_t col);
|
||||
static lv_res_t get_pressed_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col);
|
||||
static size_t get_cell_txt_len(const char * txt);
|
||||
static void copy_cell_txt(char * dst, const char * txt);
|
||||
static void copy_cell_txt(lv_table_cell_t * dst, const char * txt);
|
||||
static void get_cell_area(lv_obj_t * obj, uint16_t row, uint16_t col, lv_area_t * area);
|
||||
static void scroll_to_selected_cell(lv_obj_t * obj);
|
||||
|
||||
|
|
@ -98,7 +98,14 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col, const c
|
|||
lv_table_cell_ctrl_t ctrl = 0;
|
||||
|
||||
/*Save the control byte*/
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell][0];
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell]->ctrl;
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
void * user_data = NULL;
|
||||
|
||||
/*Save the user data*/
|
||||
if(table->cell_data[cell]) user_data = table->cell_data[cell]->user_data;
|
||||
#endif
|
||||
|
||||
size_t to_allocate = get_cell_txt_len(txt);
|
||||
|
||||
|
|
@ -108,7 +115,10 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col, const c
|
|||
|
||||
copy_cell_txt(table->cell_data[cell], txt);
|
||||
|
||||
table->cell_data[cell][0] = ctrl;
|
||||
table->cell_data[cell]->ctrl = ctrl;
|
||||
#if LV_USE_USER_DATA
|
||||
table->cell_data[cell]->user_data = user_data;
|
||||
#endif
|
||||
refr_cell_size(obj, row, col);
|
||||
}
|
||||
|
||||
|
|
@ -131,7 +141,14 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con
|
|||
lv_table_cell_ctrl_t ctrl = 0;
|
||||
|
||||
/*Save the control byte*/
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell][0];
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell]->ctrl;
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
void * user_data = NULL;
|
||||
|
||||
/*Save the user_data*/
|
||||
if(table->cell_data[cell]) user_data = table->cell_data[cell]->user_data;
|
||||
#endif
|
||||
|
||||
va_list ap, ap2;
|
||||
va_start(ap, fmt);
|
||||
|
|
@ -154,32 +171,35 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con
|
|||
|
||||
/*Get the size of the Arabic text and process it*/
|
||||
size_t len_ap = _lv_txt_ap_calc_bytes_cnt(raw_txt);
|
||||
table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len_ap + 1);
|
||||
table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], sizeof(lv_table_cell_t) + len_ap + 1);
|
||||
LV_ASSERT_MALLOC(table->cell_data[cell]);
|
||||
if(table->cell_data[cell] == NULL) {
|
||||
va_end(ap2);
|
||||
return;
|
||||
}
|
||||
_lv_txt_ap_proc(raw_txt, &table->cell_data[cell][1]);
|
||||
_lv_txt_ap_proc(raw_txt, table->cell_data[cell]->txt);
|
||||
|
||||
lv_mem_buf_release(raw_txt);
|
||||
#else
|
||||
table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len + 2); /*+1: trailing '\0; +1: format byte*/
|
||||
table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell],
|
||||
sizeof(lv_table_cell_t) + len + 1); /*+1: trailing '\0; */
|
||||
LV_ASSERT_MALLOC(table->cell_data[cell]);
|
||||
if(table->cell_data[cell] == NULL) {
|
||||
va_end(ap2);
|
||||
return;
|
||||
}
|
||||
|
||||
table->cell_data[cell][len + 1] = 0; /*Ensure NULL termination*/
|
||||
table->cell_data[cell]->txt[len] = 0; /*Ensure NULL termination*/
|
||||
|
||||
lv_vsnprintf(&table->cell_data[cell][1], len + 1, fmt, ap2);
|
||||
lv_vsnprintf(table->cell_data[cell]->txt, len + 1, fmt, ap2);
|
||||
#endif
|
||||
|
||||
va_end(ap2);
|
||||
|
||||
table->cell_data[cell][0] = ctrl;
|
||||
|
||||
table->cell_data[cell]->ctrl = ctrl;
|
||||
#if LV_USE_USER_DATA
|
||||
table->cell_data[cell]->user_data = user_data;
|
||||
#endif
|
||||
refr_cell_size(obj, row, col);
|
||||
}
|
||||
|
||||
|
|
@ -204,11 +224,17 @@ void lv_table_set_row_cnt(lv_obj_t * obj, uint16_t row_cnt)
|
|||
uint32_t new_cell_cnt = table->col_cnt * table->row_cnt;
|
||||
uint32_t i;
|
||||
for(i = new_cell_cnt; i < old_cell_cnt; i++) {
|
||||
#if LV_USE_USER_DATA
|
||||
if(table->cell_data[i]->user_data) {
|
||||
lv_mem_free(table->cell_data[i]->user_data);
|
||||
table->cell_data[i]->user_data = NULL;
|
||||
}
|
||||
#endif
|
||||
lv_mem_free(table->cell_data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *));
|
||||
table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
|
||||
LV_ASSERT_MALLOC(table->cell_data);
|
||||
if(table->cell_data == NULL) return;
|
||||
|
||||
|
|
@ -233,7 +259,7 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
|
|||
uint16_t old_col_cnt = table->col_cnt;
|
||||
table->col_cnt = col_cnt;
|
||||
|
||||
char ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(char *));
|
||||
lv_table_cell_t ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
|
||||
LV_ASSERT_MALLOC(new_cell_data);
|
||||
if(new_cell_data == NULL) return;
|
||||
uint32_t new_cell_cnt = table->col_cnt * table->row_cnt;
|
||||
|
|
@ -256,6 +282,12 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
|
|||
int32_t i;
|
||||
for(i = 0; i < (int32_t)old_col_cnt - col_cnt; i++) {
|
||||
uint32_t idx = old_col_start + min_col_cnt + i;
|
||||
#if LV_USE_USER_DATA
|
||||
if(table->cell_data[idx]->user_data) {
|
||||
lv_mem_free(table->cell_data[idx]->user_data);
|
||||
table->cell_data[idx]->user_data = NULL;
|
||||
}
|
||||
#endif
|
||||
lv_mem_free(table->cell_data[idx]);
|
||||
table->cell_data[idx] = NULL;
|
||||
}
|
||||
|
|
@ -304,15 +336,18 @@ void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
|
|||
uint32_t cell = row * table->col_cnt + col;
|
||||
|
||||
if(is_cell_empty(table->cell_data[cell])) {
|
||||
table->cell_data[cell] = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
|
||||
table->cell_data[cell] = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
|
||||
LV_ASSERT_MALLOC(table->cell_data[cell]);
|
||||
if(table->cell_data[cell] == NULL) return;
|
||||
|
||||
table->cell_data[cell][0] = 0;
|
||||
table->cell_data[cell][1] = '\0';
|
||||
table->cell_data[cell]->ctrl = 0;
|
||||
#if LV_USE_USER_DATA
|
||||
table->cell_data[cell]->user_data = NULL;
|
||||
#endif
|
||||
table->cell_data[cell]->txt[0] = '\0';
|
||||
}
|
||||
|
||||
table->cell_data[cell][0] |= ctrl;
|
||||
table->cell_data[cell]->ctrl |= ctrl;
|
||||
}
|
||||
|
||||
void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
|
||||
|
|
@ -328,17 +363,51 @@ void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_tab
|
|||
uint32_t cell = row * table->col_cnt + col;
|
||||
|
||||
if(is_cell_empty(table->cell_data[cell])) {
|
||||
table->cell_data[cell] = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
|
||||
table->cell_data[cell] = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
|
||||
LV_ASSERT_MALLOC(table->cell_data[cell]);
|
||||
if(table->cell_data[cell] == NULL) return;
|
||||
|
||||
table->cell_data[cell][0] = 0;
|
||||
table->cell_data[cell][1] = '\0';
|
||||
table->cell_data[cell]->ctrl = 0;
|
||||
#if LV_USE_USER_DATA
|
||||
table->cell_data[cell]->user_data = NULL;
|
||||
#endif
|
||||
table->cell_data[cell]->txt[0] = '\0';
|
||||
}
|
||||
|
||||
table->cell_data[cell][0] &= (~ctrl);
|
||||
table->cell_data[cell]->ctrl &= (~ctrl);
|
||||
}
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
|
||||
lv_table_t * table = (lv_table_t *)obj;
|
||||
|
||||
/*Auto expand*/
|
||||
if(col >= table->col_cnt) lv_table_set_col_cnt(obj, col + 1);
|
||||
if(row >= table->row_cnt) lv_table_set_row_cnt(obj, row + 1);
|
||||
|
||||
uint32_t cell = row * table->col_cnt + col;
|
||||
|
||||
if(is_cell_empty(table->cell_data[cell])) {
|
||||
table->cell_data[cell] = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
|
||||
LV_ASSERT_MALLOC(table->cell_data[cell]);
|
||||
if(table->cell_data[cell] == NULL) return;
|
||||
|
||||
table->cell_data[cell]->ctrl = 0;
|
||||
table->cell_data[cell]->user_data = NULL;
|
||||
table->cell_data[cell]->txt[0] = '\0';
|
||||
}
|
||||
|
||||
if(table->cell_data[cell]->user_data) {
|
||||
lv_mem_free(table->cell_data[cell]->user_data);
|
||||
}
|
||||
|
||||
table->cell_data[cell]->user_data = user_data;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*=====================
|
||||
* Getter functions
|
||||
*====================*/
|
||||
|
|
@ -356,7 +425,7 @@ const char * lv_table_get_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col)
|
|||
|
||||
if(is_cell_empty(table->cell_data[cell])) return "";
|
||||
|
||||
return &table->cell_data[cell][1]; /*Skip the format byte*/
|
||||
return table->cell_data[cell]->txt;
|
||||
}
|
||||
|
||||
uint16_t lv_table_get_row_cnt(lv_obj_t * obj)
|
||||
|
|
@ -401,7 +470,7 @@ bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
|
|||
uint32_t cell = row * table->col_cnt + col;
|
||||
|
||||
if(is_cell_empty(table->cell_data[cell])) return false;
|
||||
else return (table->cell_data[cell][0] & ctrl) == ctrl;
|
||||
else return (table->cell_data[cell]->ctrl & ctrl) == ctrl;
|
||||
}
|
||||
|
||||
void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
|
||||
|
|
@ -411,6 +480,24 @@ void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
|
|||
*col = table->col_act;
|
||||
}
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
|
||||
lv_table_t * table = (lv_table_t *)obj;
|
||||
if(row >= table->row_cnt || col >= table->col_cnt) {
|
||||
LV_LOG_WARN("invalid row or column");
|
||||
return NULL;
|
||||
}
|
||||
uint32_t cell = row * table->col_cnt + col;
|
||||
|
||||
if(is_cell_empty(table->cell_data[cell])) return NULL;
|
||||
|
||||
return table->cell_data[cell]->user_data;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
|
@ -428,7 +515,7 @@ static void lv_table_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
|||
table->row_h = lv_mem_alloc(table->row_cnt * sizeof(table->row_h[0]));
|
||||
table->col_w[0] = LV_DPI_DEF;
|
||||
table->row_h[0] = LV_DPI_DEF;
|
||||
table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *));
|
||||
table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
|
||||
table->cell_data[0] = NULL;
|
||||
|
||||
LV_TRACE_OBJ_CREATE("finished");
|
||||
|
|
@ -442,6 +529,12 @@ static void lv_table_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
|||
uint16_t i;
|
||||
for(i = 0; i < table->col_cnt * table->row_cnt; i++) {
|
||||
if(table->cell_data[i]) {
|
||||
#if LV_USE_USER_DATA
|
||||
if(table->cell_data[i]->user_data) {
|
||||
lv_mem_free(table->cell_data[i]->user_data);
|
||||
table->cell_data[i]->user_data = NULL;
|
||||
}
|
||||
#endif
|
||||
lv_mem_free(table->cell_data[i]);
|
||||
table->cell_data[i] = NULL;
|
||||
}
|
||||
|
|
@ -639,7 +732,7 @@ static void draw_main(lv_event_t * e)
|
|||
|
||||
for(col = 0; col < table->col_cnt; col++) {
|
||||
lv_table_cell_ctrl_t ctrl = 0;
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell][0];
|
||||
if(table->cell_data[cell]) ctrl = table->cell_data[cell]->ctrl;
|
||||
|
||||
if(rtl) {
|
||||
cell_area.x2 = cell_area.x1 - 1;
|
||||
|
|
@ -652,11 +745,11 @@ static void draw_main(lv_event_t * e)
|
|||
|
||||
uint16_t col_merge = 0;
|
||||
for(col_merge = 0; col_merge + col < table->col_cnt - 1; col_merge++) {
|
||||
char * next_cell_data = table->cell_data[cell + col_merge];
|
||||
lv_table_cell_t * next_cell_data = table->cell_data[cell + col_merge];
|
||||
|
||||
if(is_cell_empty(next_cell_data)) break;
|
||||
|
||||
lv_table_cell_ctrl_t merge_ctrl = (lv_table_cell_ctrl_t) next_cell_data[0];
|
||||
lv_table_cell_ctrl_t merge_ctrl = (lv_table_cell_ctrl_t) next_cell_data->ctrl;
|
||||
if(merge_ctrl & LV_TABLE_CELL_CTRL_MERGE_RIGHT) {
|
||||
lv_coord_t offset = table->col_w[col + col_merge + 1];
|
||||
|
||||
|
|
@ -739,7 +832,7 @@ static void draw_main(lv_event_t * e)
|
|||
bool crop = ctrl & LV_TABLE_CELL_CTRL_TEXT_CROP ? true : false;
|
||||
if(crop) txt_flags = LV_TEXT_FLAG_EXPAND;
|
||||
|
||||
lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, label_dsc_def.font,
|
||||
lv_txt_get_size(&txt_size, table->cell_data[cell]->txt, label_dsc_def.font,
|
||||
label_dsc_act.letter_space, label_dsc_act.line_space,
|
||||
lv_area_get_width(&txt_area), txt_flags);
|
||||
|
||||
|
|
@ -754,7 +847,7 @@ static void draw_main(lv_event_t * e)
|
|||
label_mask_ok = _lv_area_intersect(&label_clip_area, &clip_area, &cell_area);
|
||||
if(label_mask_ok) {
|
||||
draw_ctx->clip_area = &label_clip_area;
|
||||
lv_draw_label(draw_ctx, &label_dsc_act, &txt_area, table->cell_data[cell] + 1, NULL);
|
||||
lv_draw_label(draw_ctx, &label_dsc_act, &txt_area, table->cell_data[cell]->txt, NULL);
|
||||
draw_ctx->clip_area = &clip_area;
|
||||
}
|
||||
}
|
||||
|
|
@ -845,7 +938,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
|
|||
uint16_t cell;
|
||||
uint16_t col;
|
||||
for(cell = row_start, col = 0; cell < row_start + table->col_cnt; cell++, col++) {
|
||||
char * cell_data = table->cell_data[cell];
|
||||
lv_table_cell_t * cell_data = table->cell_data[cell];
|
||||
|
||||
if(is_cell_empty(cell_data)) {
|
||||
continue;
|
||||
|
|
@ -858,11 +951,11 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
|
|||
* exit the traversal when the current cell control is not LV_TABLE_CELL_CTRL_MERGE_RIGHT */
|
||||
uint16_t col_merge = 0;
|
||||
for(col_merge = 0; col_merge + col < table->col_cnt - 1; col_merge++) {
|
||||
char * next_cell_data = table->cell_data[cell + col_merge];
|
||||
lv_table_cell_t * next_cell_data = table->cell_data[cell + col_merge];
|
||||
|
||||
if(is_cell_empty(next_cell_data)) break;
|
||||
|
||||
lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) next_cell_data[0];
|
||||
lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) next_cell_data->ctrl;
|
||||
if(ctrl & LV_TABLE_CELL_CTRL_MERGE_RIGHT) {
|
||||
txt_w += table->col_w[col + col_merge + 1];
|
||||
}
|
||||
|
|
@ -871,7 +964,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
|
|||
}
|
||||
}
|
||||
|
||||
lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) cell_data[0];
|
||||
lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) cell_data->ctrl;
|
||||
|
||||
/*When cropping the text we can assume the row height is equal to the line height*/
|
||||
if(ctrl & LV_TABLE_CELL_CTRL_TEXT_CROP) {
|
||||
|
|
@ -883,7 +976,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
|
|||
lv_point_t txt_size;
|
||||
txt_w -= cell_left + cell_right;
|
||||
|
||||
lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, font,
|
||||
lv_txt_get_size(&txt_size, table->cell_data[cell]->txt, font,
|
||||
letter_space, line_space, txt_w, LV_TEXT_FLAG_NONE);
|
||||
|
||||
h_max = LV_MAX(txt_size.y + cell_top + cell_bottom, h_max);
|
||||
|
|
@ -953,23 +1046,21 @@ static size_t get_cell_txt_len(const char * txt)
|
|||
size_t retval = 0;
|
||||
|
||||
#if LV_USE_ARABIC_PERSIAN_CHARS
|
||||
retval = _lv_txt_ap_calc_bytes_cnt(txt) + 1;
|
||||
retval = sizeof(lv_table_cell_t) + _lv_txt_ap_calc_bytes_cnt(txt) + 1;
|
||||
#else
|
||||
/* cell_data layout: [ctrl][txt][trailing '\0' terminator]
|
||||
* +2 because of the trailing '\0' and the ctrl */
|
||||
retval = strlen(txt) + 2;
|
||||
retval = sizeof(lv_table_cell_t) + strlen(txt) + 1;
|
||||
#endif
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Copy txt into dst skipping the format byte */
|
||||
static void copy_cell_txt(char * dst, const char * txt)
|
||||
static void copy_cell_txt(lv_table_cell_t * dst, const char * txt)
|
||||
{
|
||||
#if LV_USE_ARABIC_PERSIAN_CHARS
|
||||
_lv_txt_ap_proc(txt, &dst[1]);
|
||||
_lv_txt_ap_proc(txt, dst->txt);
|
||||
#else
|
||||
strcpy(&dst[1], txt);
|
||||
strcpy(dst->txt, txt);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -46,12 +46,21 @@ enum {
|
|||
|
||||
typedef uint8_t lv_table_cell_ctrl_t;
|
||||
|
||||
/*Data of cell*/
|
||||
typedef struct {
|
||||
lv_table_cell_ctrl_t ctrl;
|
||||
#if LV_USE_USER_DATA
|
||||
void * user_data; /**< Custom user data*/
|
||||
#endif
|
||||
char txt[];
|
||||
} lv_table_cell_t;
|
||||
|
||||
/*Data of table*/
|
||||
typedef struct {
|
||||
lv_obj_t obj;
|
||||
uint16_t col_cnt;
|
||||
uint16_t row_cnt;
|
||||
char ** cell_data;
|
||||
lv_table_cell_t ** cell_data;
|
||||
lv_coord_t * row_h;
|
||||
lv_coord_t * col_w;
|
||||
uint16_t col_act;
|
||||
|
|
@ -144,6 +153,17 @@ void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
|
|||
*/
|
||||
void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl);
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
/**
|
||||
* Add custom user data to the cell.
|
||||
* @param obj pointer to a Table object
|
||||
* @param row id of the row [0 .. row_cnt -1]
|
||||
* @param col id of the column [0 .. col_cnt -1]
|
||||
* @param user_data pointer to the new user_data. It must be allocated by user as it will be freed automatically
|
||||
*/
|
||||
void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data);
|
||||
#endif
|
||||
|
||||
/*=====================
|
||||
* Getter functions
|
||||
*====================*/
|
||||
|
|
@ -197,6 +217,16 @@ bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
|
|||
*/
|
||||
void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col);
|
||||
|
||||
#if LV_USE_USER_DATA
|
||||
/**
|
||||
* Get custom user data to the cell.
|
||||
* @param obj pointer to a Table object
|
||||
* @param row id of the row [0 .. row_cnt -1]
|
||||
* @param col id of the column [0 .. col_cnt -1]
|
||||
*/
|
||||
void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col);
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
|
|
|||
Loading…
Reference in New Issue