jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-23 02:36:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'arendst:development' into development

Browse Source
This commit is contained in:
mikep1998 2021-05-21 18:11:23 -07:00
commit 0d69c2a9fd
77 changed files with 14031 additions and 10554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1420
lib/libesp32/Berry/default/be_lv_lvgl_module.c
View File

File diff suppressed because it is too large Load Diff

2052
lib/libesp32/Berry/default/be_lvgl_widgets_lib.c
View File

File diff suppressed because it is too large Load Diff

2
lib/libesp32/Berry/default/berry_conf.h
View File

@ -75,7 +75,7 @@
* Set the maximum total stack size.
* Default: 20000
**/
#define BE_STACK_TOTAL_MAX 4000
#define BE_STACK_TOTAL_MAX 8000
/* Macro: BE_STACK_FREE_MIN
* Set the minimum free count of the stack. The stack idles will

2279
lib/libesp32/Berry/generate/be_const_strtab.h
View File

File diff suppressed because it is too large Load Diff

3378
lib/libesp32/Berry/generate/be_const_strtab_def.h
View File

File diff suppressed because it is too large Load Diff

30
lib/libesp32/Berry/generate/be_fixed_be_class_lv_arc.h
View File

@ -1,37 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_arc_map) {
{ be_const_key(set_type, -1), be_const_func(lvbe_arc_set_type) },
{ be_const_key(set_adjustable, -1), be_const_func(lvbe_arc_set_adjustable) },
{ be_const_key(set_bg_start_angle, -1), be_const_func(lvbe_arc_set_bg_start_angle) },
{ be_const_key(set_chg_rate, -1), be_const_func(lvbe_arc_set_chg_rate) },
{ be_const_key(set_start_angle, 18), be_const_func(lvbe_arc_set_start_angle) },
{ be_const_key(get_min_value, -1), be_const_func(lvbe_arc_get_min_value) },
{ be_const_key(create, 7), be_const_func(lvbe_arc_create) },
{ be_const_key(dot_p, 16), be_const_int(0) },
{ be_const_key(get_bg_angle_start, 5), be_const_func(lvbe_arc_get_bg_angle_start) },
{ be_const_key(is_dragged, -1), be_const_func(lvbe_arc_is_dragged) },
{ be_const_key(set_range, 21), be_const_func(lvbe_arc_set_range) },
{ be_const_key(get_angle_end, 6), be_const_func(lvbe_arc_get_angle_end) },
{ be_const_key(get_max_value, 9), be_const_func(lvbe_arc_get_max_value) },
{ be_const_key(init, 2), be_const_func(lvbe_arc_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_bg_angles, -1), be_const_func(lvbe_arc_set_bg_angles) },
{ be_const_key(set_end_angle, -1), be_const_func(lvbe_arc_set_end_angle) },
{ be_const_key(set_bg_end_angle, 23), be_const_func(lvbe_arc_set_bg_end_angle) },
{ be_const_key(get_adjustable, -1), be_const_func(lvbe_arc_get_adjustable) },
{ be_const_key(set_rotation, -1), be_const_func(lvbe_arc_set_rotation) },
{ be_const_key(set_value, 10), be_const_func(lvbe_arc_set_value) },
{ be_const_key(set_angles, -1), be_const_func(lvbe_arc_set_angles) },
{ be_const_key(init, -1), be_const_func(lvbe_arc_create) },
{ be_const_key(get_angle_start, -1), be_const_func(lvbe_arc_get_angle_start) },
{ be_const_key(get_bg_angle_end, -1), be_const_func(lvbe_arc_get_bg_angle_end) },
{ be_const_key(get_type, 4), be_const_func(lvbe_arc_get_type) },
{ be_const_key(get_value, 15), be_const_func(lvbe_arc_get_value) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_arc_map,
26
4
);
BE_EXPORT_VARIABLE be_define_const_class(

19
lib/libesp32/Berry/generate/be_fixed_be_class_lv_bar.h
View File

@ -1,26 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_bar_map) {
{ be_const_key(set_value, 8), be_const_func(lvbe_bar_set_value) },
{ be_const_key(get_anim_time, -1), be_const_func(lvbe_bar_get_anim_time) },
{ be_const_key(set_anim_time, 7), be_const_func(lvbe_bar_set_anim_time) },
{ be_const_key(set_range, -1), be_const_func(lvbe_bar_set_range) },
{ be_const_key(get_type, 11), be_const_func(lvbe_bar_get_type) },
{ be_const_key(get_start_value, -1), be_const_func(lvbe_bar_get_start_value) },
{ be_const_key(set_type, -1), be_const_func(lvbe_bar_set_type) },
{ be_const_key(create, -1), be_const_func(lvbe_bar_create) },
{ be_const_key(init, -1), be_const_func(lvbe_bar_create) },
{ be_const_key(get_min_value, -1), be_const_func(lvbe_bar_get_min_value) },
{ be_const_key(tostring, 1), be_const_func(lvx_tostring) },
{ be_const_key(set_start_value, 13), be_const_func(lvbe_bar_set_start_value) },
{ be_const_key(get_value, -1), be_const_func(lvbe_bar_get_value) },
{ be_const_key(init, 2), be_const_func(lvbe_bar_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_max_value, -1), be_const_func(lvbe_bar_get_max_value) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_bar_map,
15
4
);
BE_EXPORT_VARIABLE be_define_const_class(

24
lib/libesp32/Berry/generate/be_fixed_be_class_lv_btn.h
View File

@ -1,29 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_btn_map) {
{ be_const_key(get_state, -1), be_const_func(lvbe_btn_get_state) },
{ be_const_key(get_fit_top, 10), be_const_func(lvbe_btn_get_fit_top) },
{ be_const_key(get_fit_bottom, 0), be_const_func(lvbe_btn_get_fit_bottom) },
{ be_const_key(set_fit4, -1), be_const_func(lvbe_btn_set_fit4) },
{ be_const_key(get_fit_right, -1), be_const_func(lvbe_btn_get_fit_right) },
{ be_const_key(create, -1), be_const_func(lvbe_btn_create) },
{ be_const_key(set_fit, -1), be_const_func(lvbe_btn_set_fit) },
{ be_const_key(tostring, 3), be_const_func(lvx_tostring) },
{ be_const_key(set_layout, -1), be_const_func(lvbe_btn_set_layout) },
{ be_const_key(get_fit_left, -1), be_const_func(lvbe_btn_get_fit_left) },
{ be_const_key(dot_p, 13), be_const_int(0) },
{ be_const_key(set_state, 6), be_const_func(lvbe_btn_set_state) },
{ be_const_key(set_checkable, 14), be_const_func(lvbe_btn_set_checkable) },
{ be_const_key(toggle, -1), be_const_func(lvbe_btn_toggle) },
{ be_const_key(get_layout, 16), be_const_func(lvbe_btn_get_layout) },
{ be_const_key(init, 9), be_const_func(lvbe_btn_create) },
{ be_const_key(get_checkable, -1), be_const_func(lvbe_btn_get_checkable) },
{ be_const_key(set_fit2, 2), be_const_func(lvbe_btn_set_fit2) },
{ be_const_key(init, 2), be_const_func(lvbe_btn_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_btn_map,
18
4
);
BE_EXPORT_VARIABLE be_define_const_class(

27
lib/libesp32/Berry/generate/be_fixed_be_class_lv_btnmatrix.h
View File

@ -1,34 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_btnmatrix_map) {
{ be_const_key(clear_btn_ctrl, 13), be_const_func(lvbe_btnmatrix_clear_btn_ctrl) },
{ be_const_key(set_align, -1), be_const_func(lvbe_btnmatrix_set_align) },
{ be_const_key(get_btn_text, 7), be_const_func(lvbe_btnmatrix_get_btn_text) },
{ be_const_key(get_active_btn_text, -1), be_const_func(lvbe_btnmatrix_get_active_btn_text) },
{ be_const_key(create, 3), be_const_func(lvbe_btnmatrix_create) },
{ be_const_key(set_btn_ctrl_all, -1), be_const_func(lvbe_btnmatrix_set_btn_ctrl_all) },
{ be_const_key(clear_btn_ctrl_all, 12), be_const_func(lvbe_btnmatrix_clear_btn_ctrl_all) },
{ be_const_key(get_one_check, -1), be_const_func(lvbe_btnmatrix_get_one_check) },
{ be_const_key(get_active_btn, -1), be_const_func(lvbe_btnmatrix_get_active_btn) },
{ be_const_key(get_align, 22), be_const_func(lvbe_btnmatrix_get_align) },
{ be_const_key(set_focused_btn, 4), be_const_func(lvbe_btnmatrix_set_focused_btn) },
{ be_const_key(set_map, -1), be_const_func(lvbe_btnmatrix_set_map) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_one_check, 20), be_const_func(lvbe_btnmatrix_set_one_check) },
{ be_const_key(init, -1), be_const_func(lvbe_btnmatrix_create) },
{ be_const_key(get_recolor, -1), be_const_func(lvbe_btnmatrix_get_recolor) },
{ be_const_key(set_recolor, 8), be_const_func(lvbe_btnmatrix_set_recolor) },
{ be_const_key(set_btn_ctrl, -1), be_const_func(lvbe_btnmatrix_set_btn_ctrl) },
{ be_const_key(get_focused_btn, -1), be_const_func(lvbe_btnmatrix_get_focused_btn) },
{ be_const_key(set_btn_width, 0), be_const_func(lvbe_btnmatrix_set_btn_width) },
{ be_const_key(get_btn_ctrl, -1), be_const_func(lvbe_btnmatrix_get_btn_ctrl) },
{ be_const_key(set_ctrl_map, 5), be_const_func(lvbe_btnmatrix_set_ctrl_map) },
{ be_const_key(init, 2), be_const_func(lvbe_btnmatrix_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_btnmatrix_map,
23
4
);
BE_EXPORT_VARIABLE be_define_const_class(

13
lib/libesp32/Berry/generate/be_fixed_be_class_lv_calendar.h
View File

@ -1,22 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_calendar_map) {
{ be_const_key(create, -1), be_const_func(lvbe_calendar_create) },
{ be_const_key(get_day_of_week, -1), be_const_func(lvbe_calendar_get_day_of_week) },
{ be_const_key(get_highlighted_dates_num, 5), be_const_func(lvbe_calendar_get_highlighted_dates_num) },
{ be_const_key(init, 2), be_const_func(lvbe_calendar_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_highlighted_dates, -1), be_const_func(lvbe_calendar_set_highlighted_dates) },
{ be_const_key(set_showed_date, -1), be_const_func(lvbe_calendar_set_showed_date) },
{ be_const_key(set_day_names, -1), be_const_func(lvbe_calendar_set_day_names) },
{ be_const_key(set_today_date, -1), be_const_func(lvbe_calendar_set_today_date) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(init, 4), be_const_func(lvbe_calendar_create) },
{ be_const_key(set_month_names, -1), be_const_func(lvbe_calendar_set_month_names) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_calendar_map,
11
4
);
BE_EXPORT_VARIABLE be_define_const_class(

21
lib/libesp32/Berry/generate/be_fixed_be_class_lv_canvas.h
View File

@ -1,30 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_canvas_map) {
{ be_const_key(init, 16), be_const_func(lvbe_canvas_create) },
{ be_const_key(set_palette, -1), be_const_func(lvbe_canvas_set_palette) },
{ be_const_key(init, 2), be_const_func(lvbe_canvas_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(draw_img, -1), be_const_func(lvbe_canvas_draw_img) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(copy_buf, 6), be_const_func(lvbe_canvas_copy_buf) },
{ be_const_key(create, 17), be_const_func(lvbe_canvas_create) },
{ be_const_key(draw_arc, 10), be_const_func(lvbe_canvas_draw_arc) },
{ be_const_key(get_px, 7), be_const_func(lvbe_canvas_get_px) },
{ be_const_key(transform, -1), be_const_func(lvbe_canvas_transform) },
{ be_const_key(draw_text, 3), be_const_func(lvbe_canvas_draw_text) },
{ be_const_key(fill_bg, -1), be_const_func(lvbe_canvas_fill_bg) },
{ be_const_key(draw_polygon, -1), be_const_func(lvbe_canvas_draw_polygon) },
{ be_const_key(blur_ver, 0), be_const_func(lvbe_canvas_blur_ver) },
{ be_const_key(blur_hor, -1), be_const_func(lvbe_canvas_blur_hor) },
{ be_const_key(draw_line, -1), be_const_func(lvbe_canvas_draw_line) },
{ be_const_key(draw_rect, -1), be_const_func(lvbe_canvas_draw_rect) },
{ be_const_key(set_buffer, -1), be_const_func(lvbe_canvas_set_buffer) },
{ be_const_key(set_px, -1), be_const_func(lvbe_canvas_set_px) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_canvas_map,
19
4
);
BE_EXPORT_VARIABLE be_define_const_class(

41
lib/libesp32/Berry/generate/be_fixed_be_class_lv_chart.h
View File

@ -1,48 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_chart_map) {
{ be_const_key(init, -1), be_const_func(lvbe_chart_create) },
{ be_const_key(set_secondary_y_tick_length, -1), be_const_func(lvbe_chart_set_secondary_y_tick_length) },
{ be_const_key(create, -1), be_const_func(lvbe_chart_create) },
{ be_const_key(set_x_tick_length, -1), be_const_func(lvbe_chart_set_x_tick_length) },
{ be_const_key(set_next, -1), be_const_func(lvbe_chart_set_next) },
{ be_const_key(set_x_start_point, 14), be_const_func(lvbe_chart_set_x_start_point) },
{ be_const_key(set_point_id, 23), be_const_func(lvbe_chart_set_point_id) },
{ be_const_key(init, 2), be_const_func(lvbe_chart_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_ext_array, 12), be_const_func(lvbe_chart_set_ext_array) },
{ be_const_key(get_cursor_point, 4), be_const_func(lvbe_chart_get_cursor_point) },
{ be_const_key(hide_series, -1), be_const_func(lvbe_chart_hide_series) },
{ be_const_key(refresh, -1), be_const_func(lvbe_chart_refresh) },
{ be_const_key(set_point_count, -1), be_const_func(lvbe_chart_set_point_count) },
{ be_const_key(set_secondary_y_tick_texts, -1), be_const_func(lvbe_chart_set_secondary_y_tick_texts) },
{ be_const_key(set_points, 27), be_const_func(lvbe_chart_set_points) },
{ be_const_key(set_update_mode, -1), be_const_func(lvbe_chart_set_update_mode) },
{ be_const_key(set_y_tick_texts, 1), be_const_func(lvbe_chart_set_y_tick_texts) },
{ be_const_key(set_cursor_point, -1), be_const_func(lvbe_chart_set_cursor_point) },
{ be_const_key(get_point_count, -1), be_const_func(lvbe_chart_get_point_count) },
{ be_const_key(init_points, 20), be_const_func(lvbe_chart_init_points) },
{ be_const_key(remove_series, -1), be_const_func(lvbe_chart_remove_series) },
{ be_const_key(set_series_axis, 8), be_const_func(lvbe_chart_set_series_axis) },
{ be_const_key(set_type, -1), be_const_func(lvbe_chart_set_type) },
{ be_const_key(clear_series, -1), be_const_func(lvbe_chart_clear_series) },
{ be_const_key(set_div_line_count, -1), be_const_func(lvbe_chart_set_div_line_count) },
{ be_const_key(get_point_id, 31), be_const_func(lvbe_chart_get_point_id) },
{ be_const_key(tostring, 17), be_const_func(lvx_tostring) },
{ be_const_key(set_y_range, -1), be_const_func(lvbe_chart_set_y_range) },
{ be_const_key(get_type, -1), be_const_func(lvbe_chart_get_type) },
{ be_const_key(get_series_axis, 30), be_const_func(lvbe_chart_get_series_axis) },
{ be_const_key(set_y_tick_length, -1), be_const_func(lvbe_chart_set_y_tick_length) },
{ be_const_key(get_nearest_index_from_coord, -1), be_const_func(lvbe_chart_get_nearest_index_from_coord) },
{ be_const_key(set_x_tick_texts, -1), be_const_func(lvbe_chart_set_x_tick_texts) },
{ be_const_key(get_x_from_index, -1), be_const_func(lvbe_chart_get_x_from_index) },
{ be_const_key(get_x_start_point, -1), be_const_func(lvbe_chart_get_x_start_point) },
{ be_const_key(get_series_area, 33), be_const_func(lvbe_chart_get_series_area) },
{ be_const_key(get_y_from_index, -1), be_const_func(lvbe_chart_get_y_from_index) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_chart_map,
37
4
);
BE_EXPORT_VARIABLE be_define_const_class(

17
lib/libesp32/Berry/generate/be_fixed_be_class_lv_checkbox.h
View File

@ -1,24 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_checkbox_map) {
{ be_const_key(init, 2), be_const_func(lvbe_checkbox_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(get_state, -1), be_const_func(lvbe_checkbox_get_state) },
{ be_const_key(is_checked, 7), be_const_func(lvbe_checkbox_is_checked) },
{ be_const_key(dot_p, 4), be_const_int(0) },
{ be_const_key(create, 9), be_const_func(lvbe_checkbox_create) },
{ be_const_key(set_state, -1), be_const_func(lvbe_checkbox_set_state) },
{ be_const_key(is_inactive, 10), be_const_func(lvbe_checkbox_is_inactive) },
{ be_const_key(set_disabled, -1), be_const_func(lvbe_checkbox_set_disabled) },
{ be_const_key(set_checked, -1), be_const_func(lvbe_checkbox_set_checked) },
{ be_const_key(get_text, -1), be_const_func(lvbe_checkbox_get_text) },
{ be_const_key(init, -1), be_const_func(lvbe_checkbox_create) },
{ be_const_key(set_text, 3), be_const_func(lvbe_checkbox_set_text) },
{ be_const_key(set_text_static, 2), be_const_func(lvbe_checkbox_set_text_static) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_checkbox_map,
13
4
);
BE_EXPORT_VARIABLE be_define_const_class(

17
lib/libesp32/Berry/generate/be_fixed_be_class_lv_cont.h
View File

@ -1,24 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_cont_map) {
{ be_const_key(init, 2), be_const_func(lvbe_cont_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(get_layout, -1), be_const_func(lvbe_cont_get_layout) },
{ be_const_key(set_fit2, -1), be_const_func(lvbe_cont_set_fit2) },
{ be_const_key(set_fit, -1), be_const_func(lvbe_cont_set_fit) },
{ be_const_key(get_fit_top, -1), be_const_func(lvbe_cont_get_fit_top) },
{ be_const_key(get_fit_bottom, -1), be_const_func(lvbe_cont_get_fit_bottom) },
{ be_const_key(init, 9), be_const_func(lvbe_cont_create) },
{ be_const_key(create, -1), be_const_func(lvbe_cont_create) },
{ be_const_key(get_fit_right, 1), be_const_func(lvbe_cont_get_fit_right) },
{ be_const_key(get_fit_left, -1), be_const_func(lvbe_cont_get_fit_left) },
{ be_const_key(set_layout, -1), be_const_func(lvbe_cont_set_layout) },
{ be_const_key(dot_p, 7), be_const_int(0) },
{ be_const_key(set_fit4, -1), be_const_func(lvbe_cont_set_fit4) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_cont_map,
13
4
);
BE_EXPORT_VARIABLE be_define_const_class(

21
lib/libesp32/Berry/generate/be_fixed_be_class_lv_cpicker.h
View File

@ -2,31 +2,14 @@
static be_define_const_map_slots(be_class_lv_cpicker_map) {
{ be_const_key(init, 2), be_const_func(lvbe_cpicker_create) },
{ be_const_key(get_hue, -1), be_const_func(lvbe_cpicker_get_hue) },
{ be_const_key(get_value, -1), be_const_func(lvbe_cpicker_get_value) },
{ be_const_key(set_color, 13), be_const_func(lvbe_cpicker_set_color) },
{ be_const_key(set_color_mode, -1), be_const_func(lvbe_cpicker_set_color_mode) },
{ be_const_key(get_knob_colored, 15), be_const_func(lvbe_cpicker_get_knob_colored) },
{ be_const_key(get_color_mode, -1), be_const_func(lvbe_cpicker_get_color_mode) },
{ be_const_key(set_hsv, 18), be_const_func(lvbe_cpicker_set_hsv) },
{ be_const_key(set_saturation, -1), be_const_func(lvbe_cpicker_set_saturation) },
{ be_const_key(set_knob_colored, -1), be_const_func(lvbe_cpicker_set_knob_colored) },
{ be_const_key(set_hue, 17), be_const_func(lvbe_cpicker_set_hue) },
{ be_const_key(set_color_mode_fixed, -1), be_const_func(lvbe_cpicker_set_color_mode_fixed) },
{ be_const_key(set_value, 0), be_const_func(lvbe_cpicker_set_value) },
{ be_const_key(set_type, -1), be_const_func(lvbe_cpicker_set_type) },
{ be_const_key(create, -1), be_const_func(lvbe_cpicker_create) },
{ be_const_key(get_color, 16), be_const_func(lvbe_cpicker_get_color) },
{ be_const_key(get_color_mode_fixed, -1), be_const_func(lvbe_cpicker_get_color_mode_fixed) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_saturation, -1), be_const_func(lvbe_cpicker_get_saturation) },
{ be_const_key(get_hsv, -1), be_const_func(lvbe_cpicker_get_hsv) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_cpicker_map,
21
4
);
BE_EXPORT_VARIABLE be_define_const_class(

29
lib/libesp32/Berry/generate/be_fixed_be_class_lv_dropdown.h
View File

@ -1,36 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_dropdown_map) {
{ be_const_key(get_selected, -1), be_const_func(lvbe_dropdown_get_selected) },
{ be_const_key(get_show_selected, -1), be_const_func(lvbe_dropdown_get_show_selected) },
{ be_const_key(init, -1), be_const_func(lvbe_dropdown_create) },
{ be_const_key(set_symbol, 18), be_const_func(lvbe_dropdown_set_symbol) },
{ be_const_key(get_text, -1), be_const_func(lvbe_dropdown_get_text) },
{ be_const_key(set_text, 2), be_const_func(lvbe_dropdown_set_text) },
{ be_const_key(set_dir, 8), be_const_func(lvbe_dropdown_set_dir) },
{ be_const_key(get_dir, -1), be_const_func(lvbe_dropdown_get_dir) },
{ be_const_key(get_option_cnt, -1), be_const_func(lvbe_dropdown_get_option_cnt) },
{ be_const_key(create, -1), be_const_func(lvbe_dropdown_create) },
{ be_const_key(set_selected, -1), be_const_func(lvbe_dropdown_set_selected) },
{ be_const_key(dot_p, 24), be_const_int(0) },
{ be_const_key(open, 7), be_const_func(lvbe_dropdown_open) },
{ be_const_key(set_max_height, -1), be_const_func(lvbe_dropdown_set_max_height) },
{ be_const_key(add_option, -1), be_const_func(lvbe_dropdown_add_option) },
{ be_const_key(set_show_selected, 16), be_const_func(lvbe_dropdown_set_show_selected) },
{ be_const_key(init, 2), be_const_func(lvbe_dropdown_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_options_static, 9), be_const_func(lvbe_dropdown_set_options_static) },
{ be_const_key(clear_options, -1), be_const_func(lvbe_dropdown_clear_options) },
{ be_const_key(get_max_height, 11), be_const_func(lvbe_dropdown_get_max_height) },
{ be_const_key(set_options, 15), be_const_func(lvbe_dropdown_set_options) },
{ be_const_key(close, -1), be_const_func(lvbe_dropdown_close) },
{ be_const_key(get_selected_str, -1), be_const_func(lvbe_dropdown_get_selected_str) },
{ be_const_key(get_symbol, 13), be_const_func(lvbe_dropdown_get_symbol) },
{ be_const_key(get_options, -1), be_const_func(lvbe_dropdown_get_options) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_dropdown_map,
25
4
);
BE_EXPORT_VARIABLE be_define_const_class(

28
lib/libesp32/Berry/generate/be_fixed_be_class_lv_gauge.h
View File

@ -1,35 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_gauge_map) {
{ be_const_key(get_needle_img_pivot_y, -1), be_const_func(lvbe_gauge_get_needle_img_pivot_y) },
{ be_const_key(get_needle_img_pivot_x, -1), be_const_func(lvbe_gauge_get_needle_img_pivot_x) },
{ be_const_key(get_line_count, -1), be_const_func(lvbe_gauge_get_line_count) },
{ be_const_key(init, -1), be_const_func(lvbe_gauge_create) },
{ be_const_key(dot_p, 20), be_const_int(0) },
{ be_const_key(create, -1), be_const_func(lvbe_gauge_create) },
{ be_const_key(get_min_value, 2), be_const_func(lvbe_gauge_get_min_value) },
{ be_const_key(set_range, -1), be_const_func(lvbe_gauge_set_range) },
{ be_const_key(get_max_value, -1), be_const_func(lvbe_gauge_get_max_value) },
{ be_const_key(get_value, 7), be_const_func(lvbe_gauge_get_value) },
{ be_const_key(get_label_count, -1), be_const_func(lvbe_gauge_get_label_count) },
{ be_const_key(set_needle_img, 1), be_const_func(lvbe_gauge_set_needle_img) },
{ be_const_key(get_needle_count, -1), be_const_func(lvbe_gauge_get_needle_count) },
{ be_const_key(init, 2), be_const_func(lvbe_gauge_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_scale, -1), be_const_func(lvbe_gauge_set_scale) },
{ be_const_key(set_critical_value, 16), be_const_func(lvbe_gauge_set_critical_value) },
{ be_const_key(get_angle_offset, -1), be_const_func(lvbe_gauge_get_angle_offset) },
{ be_const_key(get_critical_value, -1), be_const_func(lvbe_gauge_get_critical_value) },
{ be_const_key(set_formatter_cb, -1), be_const_func(lvbe_gauge_set_formatter_cb) },
{ be_const_key(set_needle_count, 4), be_const_func(lvbe_gauge_set_needle_count) },
{ be_const_key(set_angle_offset, 17), be_const_func(lvbe_gauge_set_angle_offset) },
{ be_const_key(set_value, -1), be_const_func(lvbe_gauge_set_value) },
{ be_const_key(get_scale_angle, -1), be_const_func(lvbe_gauge_get_scale_angle) },
{ be_const_key(get_needle_img, 12), be_const_func(lvbe_gauge_get_needle_img) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_gauge_map,
24
4
);
BE_EXPORT_VARIABLE be_define_const_class(

26
lib/libesp32/Berry/generate/be_fixed_be_class_lv_group.h
View File

@ -1,33 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_group_map) {
{ be_const_key(get_editing, -1), be_const_func(lvbe_group_get_editing) },
{ be_const_key(focus_freeze, -1), be_const_func(lvbe_group_focus_freeze) },
{ be_const_key(get_wrap, -1), be_const_func(lvbe_group_get_wrap) },
{ be_const_key(tostring, 20), be_const_func(lvx_tostring) },
{ be_const_key(remove_all_objs, 21), be_const_func(lvbe_group_remove_all_objs) },
{ be_const_key(remove_obj, 10), be_const_func(lvbe_group_remove_obj) },
{ be_const_key(add_obj, -1), be_const_func(lvbe_group_add_obj) },
{ be_const_key(focus_obj, -1), be_const_func(lvbe_group_focus_obj) },
{ be_const_key(set_focus_cb, -1), be_const_func(lvbe_group_set_focus_cb) },
{ be_const_key(get_click_focus, 14), be_const_func(lvbe_group_get_click_focus) },
{ be_const_key(focus_next, -1), be_const_func(lvbe_group_focus_next) },
{ be_const_key(create, -1), be_const_func(lvbe_group_create) },
{ be_const_key(set_refocus_policy, 15), be_const_func(lvbe_group_set_refocus_policy) },
{ be_const_key(get_focused, -1), be_const_func(lvbe_group_get_focused) },
{ be_const_key(init, -1), be_const_func(lvbe_group_create) },
{ be_const_key(send_data, -1), be_const_func(lvbe_group_send_data) },
{ be_const_key(set_editing, -1), be_const_func(lvbe_group_set_editing) },
{ be_const_key(init, 2), be_const_func(lvbe_group_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_wrap, -1), be_const_func(lvbe_group_set_wrap) },
{ be_const_key(set_click_focus, 17), be_const_func(lvbe_group_set_click_focus) },
{ be_const_key(focus_prev, -1), be_const_func(lvbe_group_focus_prev) },
{ be_const_key(del, -1), be_const_func(lvbe_group_del) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_group_map,
22
4
);
BE_EXPORT_VARIABLE be_define_const_class(

24
lib/libesp32/Berry/generate/be_fixed_be_class_lv_img.h
View File

@ -1,33 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_img_map) {
{ be_const_key(get_offset_y, -1), be_const_func(lvbe_img_get_offset_y) },
{ be_const_key(get_zoom, 2), be_const_func(lvbe_img_get_zoom) },
{ be_const_key(set_tasmota_logo, -1), be_const_func(lvbe_img_set_tasmota_logo) },
{ be_const_key(init, 2), be_const_func(lvbe_img_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(get_pivot, 15), be_const_func(lvbe_img_get_pivot) },
{ be_const_key(get_auto_size, 1), be_const_func(lvbe_img_get_auto_size) },
{ be_const_key(get_offset_x, 4), be_const_func(lvbe_img_get_offset_x) },
{ be_const_key(set_angle, 0), be_const_func(lvbe_img_set_angle) },
{ be_const_key(get_src, -1), be_const_func(lvbe_img_get_src) },
{ be_const_key(set_zoom, 12), be_const_func(lvbe_img_set_zoom) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(create, -1), be_const_func(lvbe_img_create) },
{ be_const_key(init, -1), be_const_func(lvbe_img_create) },
{ be_const_key(get_angle, -1), be_const_func(lvbe_img_get_angle) },
{ be_const_key(set_src, -1), be_const_func(lvbe_img_set_src) },
{ be_const_key(set_pivot, 17), be_const_func(lvbe_img_set_pivot) },
{ be_const_key(set_antialias, -1), be_const_func(lvbe_img_set_antialias) },
{ be_const_key(get_antialias, -1), be_const_func(lvbe_img_get_antialias) },
{ be_const_key(set_offset_x, -1), be_const_func(lvbe_img_set_offset_x) },
{ be_const_key(set_offset_y, 10), be_const_func(lvbe_img_set_offset_y) },
{ be_const_key(get_file_name, -1), be_const_func(lvbe_img_get_file_name) },
{ be_const_key(set_auto_size, -1), be_const_func(lvbe_img_set_auto_size) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_img_map,
22
4
);
BE_EXPORT_VARIABLE be_define_const_class(

14
lib/libesp32/Berry/generate/be_fixed_be_class_lv_imgbtn.h
View File

@ -1,21 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_imgbtn_map) {
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_state, -1), be_const_func(lvbe_imgbtn_set_state) },
{ be_const_key(set_checkable, -1), be_const_func(lvbe_imgbtn_set_checkable) },
{ be_const_key(toggle, 1), be_const_func(lvbe_imgbtn_toggle) },
{ be_const_key(get_src, -1), be_const_func(lvbe_imgbtn_get_src) },
{ be_const_key(init, 6), be_const_func(lvbe_imgbtn_create) },
{ be_const_key(init, 2), be_const_func(lvbe_imgbtn_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(create, -1), be_const_func(lvbe_imgbtn_create) },
{ be_const_key(set_src, -1), be_const_func(lvbe_imgbtn_set_src) },
{ be_const_key(get_state, 0), be_const_func(lvbe_imgbtn_get_state) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_imgbtn_map,
10
4
);
BE_EXPORT_VARIABLE be_define_const_class(

12
lib/libesp32/Berry/generate/be_fixed_be_class_lv_indev.h
View File

@ -1,19 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_indev_map) {
{ be_const_key(get_type, -1), be_const_func(lvbe_indev_get_type) },
{ be_const_key(search_obj, -1), be_const_func(lvbe_indev_search_obj) },
{ be_const_key(get_obj_act, -1), be_const_func(lvbe_indev_get_obj_act) },
{ be_const_key(init, 4), be_const_func(lv0_init) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(init, 2), be_const_func(lv0_init) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(enable, -1), be_const_func(lvbe_indev_enable) },
{ be_const_key(set_group, 1), be_const_func(lvbe_indev_set_group) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_indev_map,
8
4
);
BE_EXPORT_VARIABLE be_define_const_class(

17
lib/libesp32/Berry/generate/be_fixed_be_class_lv_keyboard.h
View File

@ -1,24 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_keyboard_map) {
{ be_const_key(init, 2), be_const_func(lvbe_keyboard_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_ctrl_map, 3), be_const_func(lvbe_keyboard_set_ctrl_map) },
{ be_const_key(def_event_cb, 8), be_const_func(lvbe_keyboard_def_event_cb) },
{ be_const_key(set_textarea, 9), be_const_func(lvbe_keyboard_set_textarea) },
{ be_const_key(create, -1), be_const_func(lvbe_keyboard_create) },
{ be_const_key(get_mode, 7), be_const_func(lvbe_keyboard_get_mode) },
{ be_const_key(init, -1), be_const_func(lvbe_keyboard_create) },
{ be_const_key(set_cursor_manage, -1), be_const_func(lvbe_keyboard_set_cursor_manage) },
{ be_const_key(set_map, -1), be_const_func(lvbe_keyboard_set_map) },
{ be_const_key(set_mode, -1), be_const_func(lvbe_keyboard_set_mode) },
{ be_const_key(get_textarea, -1), be_const_func(lvbe_keyboard_get_textarea) },
{ be_const_key(dot_p, 4), be_const_int(0) },
{ be_const_key(get_cursor_manage, 1), be_const_func(lvbe_keyboard_get_cursor_manage) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_keyboard_map,
13
4
);
BE_EXPORT_VARIABLE be_define_const_class(

30
lib/libesp32/Berry/generate/be_fixed_be_class_lv_label.h
View File

@ -1,37 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_label_map) {
{ be_const_key(get_letter_on, -1), be_const_func(lvbe_label_get_letter_on) },
{ be_const_key(create, 14), be_const_func(lvbe_label_create) },
{ be_const_key(is_char_under_pos, -1), be_const_func(lvbe_label_is_char_under_pos) },
{ be_const_key(ins_text, -1), be_const_func(lvbe_label_ins_text) },
{ be_const_key(set_text_static, -1), be_const_func(lvbe_label_set_text_static) },
{ be_const_key(set_anim_speed, -1), be_const_func(lvbe_label_set_anim_speed) },
{ be_const_key(init, -1), be_const_func(lvbe_label_create) },
{ be_const_key(get_text_sel_start, -1), be_const_func(lvbe_label_get_text_sel_start) },
{ be_const_key(set_recolor, 15), be_const_func(lvbe_label_set_recolor) },
{ be_const_key(get_letter_pos, 23), be_const_func(lvbe_label_get_letter_pos) },
{ be_const_key(get_text_sel_end, -1), be_const_func(lvbe_label_get_text_sel_end) },
{ be_const_key(set_text_sel_start, 1), be_const_func(lvbe_label_set_text_sel_start) },
{ be_const_key(refr_text, 4), be_const_func(lvbe_label_refr_text) },
{ be_const_key(cut_text, 9), be_const_func(lvbe_label_cut_text) },
{ be_const_key(get_text, 16), be_const_func(lvbe_label_get_text) },
{ be_const_key(set_long_mode, -1), be_const_func(lvbe_label_set_long_mode) },
{ be_const_key(set_text, 17), be_const_func(lvbe_label_set_text) },
{ be_const_key(init, 2), be_const_func(lvbe_label_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_long_mode, -1), be_const_func(lvbe_label_get_long_mode) },
{ be_const_key(get_align, 6), be_const_func(lvbe_label_get_align) },
{ be_const_key(set_text_sel_end, 2), be_const_func(lvbe_label_set_text_sel_end) },
{ be_const_key(set_text_fmt, -1), be_const_func(lvbe_label_set_text_fmt) },
{ be_const_key(get_recolor, -1), be_const_func(lvbe_label_get_recolor) },
{ be_const_key(tostring, 24), be_const_func(lvx_tostring) },
{ be_const_key(get_anim_speed, -1), be_const_func(lvbe_label_get_anim_speed) },
{ be_const_key(set_align, -1), be_const_func(lvbe_label_set_align) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_label_map,
26
4
);
BE_EXPORT_VARIABLE be_define_const_class(

13
lib/libesp32/Berry/generate/be_fixed_be_class_lv_led.h
View File

@ -1,20 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_led_map) {
{ be_const_key(get_bright, -1), be_const_func(lvbe_led_get_bright) },
{ be_const_key(toggle, 4), be_const_func(lvbe_led_toggle) },
{ be_const_key(on, -1), be_const_func(lvbe_led_on) },
{ be_const_key(set_bright, -1), be_const_func(lvbe_led_set_bright) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(off, 8), be_const_func(lvbe_led_off) },
{ be_const_key(init, 3), be_const_func(lvbe_led_create) },
{ be_const_key(init, 2), be_const_func(lvbe_led_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(create, -1), be_const_func(lvbe_led_create) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_led_map,
9
4
);
BE_EXPORT_VARIABLE be_define_const_class(

13
lib/libesp32/Berry/generate/be_fixed_be_class_lv_line.h
View File

@ -1,20 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_line_map) {
{ be_const_key(get_y_invert, -1), be_const_func(lvbe_line_get_y_invert) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_auto_size, -1), be_const_func(lvbe_line_get_auto_size) },
{ be_const_key(init, -1), be_const_func(lvbe_line_create) },
{ be_const_key(set_auto_size, -1), be_const_func(lvbe_line_set_auto_size) },
{ be_const_key(set_points, 8), be_const_func(lvbe_line_set_points) },
{ be_const_key(set_y_invert, 3), be_const_func(lvbe_line_set_y_invert) },
{ be_const_key(init, 2), be_const_func(lvbe_line_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(create, -1), be_const_func(lvbe_line_create) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_line_map,
9
4
);
BE_EXPORT_VARIABLE be_define_const_class(

23
lib/libesp32/Berry/generate/be_fixed_be_class_lv_linemeter.h
View File

@ -1,28 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_linemeter_map) {
{ be_const_key(set_mirror, 9), be_const_func(lvbe_linemeter_set_mirror) },
{ be_const_key(get_max_value, 10), be_const_func(lvbe_linemeter_get_max_value) },
{ be_const_key(tostring, 12), be_const_func(lvx_tostring) },
{ be_const_key(set_value, -1), be_const_func(lvbe_linemeter_set_value) },
{ be_const_key(set_angle_offset, -1), be_const_func(lvbe_linemeter_set_angle_offset) },
{ be_const_key(draw_scale, -1), be_const_func(lvbe_linemeter_draw_scale) },
{ be_const_key(get_mirror, 11), be_const_func(lvbe_linemeter_get_mirror) },
{ be_const_key(get_line_count, -1), be_const_func(lvbe_linemeter_get_line_count) },
{ be_const_key(set_scale, -1), be_const_func(lvbe_linemeter_set_scale) },
{ be_const_key(get_value, -1), be_const_func(lvbe_linemeter_get_value) },
{ be_const_key(get_scale_angle, -1), be_const_func(lvbe_linemeter_get_scale_angle) },
{ be_const_key(get_angle_offset, -1), be_const_func(lvbe_linemeter_get_angle_offset) },
{ be_const_key(set_range, -1), be_const_func(lvbe_linemeter_set_range) },
{ be_const_key(dot_p, 5), be_const_int(0) },
{ be_const_key(get_min_value, -1), be_const_func(lvbe_linemeter_get_min_value) },
{ be_const_key(init, -1), be_const_func(lvbe_linemeter_create) },
{ be_const_key(create, -1), be_const_func(lvbe_linemeter_create) },
{ be_const_key(init, 2), be_const_func(lvbe_linemeter_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_linemeter_map,
17
4
);
BE_EXPORT_VARIABLE be_define_const_class(

31
lib/libesp32/Berry/generate/be_fixed_be_class_lv_list.h
View File

@ -1,40 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_list_map) {
{ be_const_key(remove, -1), be_const_func(lvbe_list_remove) },
{ be_const_key(get_edge_flash, 16), be_const_func(lvbe_list_get_edge_flash) },
{ be_const_key(get_anim_time, -1), be_const_func(lvbe_list_get_anim_time) },
{ be_const_key(init, 2), be_const_func(lvbe_list_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(get_btn_label, 24), be_const_func(lvbe_list_get_btn_label) },
{ be_const_key(up, -1), be_const_func(lvbe_list_up) },
{ be_const_key(get_scrollbar_mode, -1), be_const_func(lvbe_list_get_scrollbar_mode) },
{ be_const_key(get_prev_btn, 28), be_const_func(lvbe_list_get_prev_btn) },
{ be_const_key(get_scroll_propagation, 14), be_const_func(lvbe_list_get_scroll_propagation) },
{ be_const_key(focus, 13), be_const_func(lvbe_list_focus) },
{ be_const_key(get_layout, 4), be_const_func(lvbe_list_get_layout) },
{ be_const_key(down, -1), be_const_func(lvbe_list_down) },
{ be_const_key(get_btn_index, -1), be_const_func(lvbe_list_get_btn_index) },
{ be_const_key(clean, -1), be_const_func(lvbe_list_clean) },
{ be_const_key(create, -1), be_const_func(lvbe_list_create) },
{ be_const_key(get_next_btn, -1), be_const_func(lvbe_list_get_next_btn) },
{ be_const_key(get_btn_img, -1), be_const_func(lvbe_list_get_btn_img) },
{ be_const_key(get_btn_selected, -1), be_const_func(lvbe_list_get_btn_selected) },
{ be_const_key(set_edge_flash, -1), be_const_func(lvbe_list_set_edge_flash) },
{ be_const_key(get_btn_text, -1), be_const_func(lvbe_list_get_btn_text) },
{ be_const_key(set_layout, -1), be_const_func(lvbe_list_set_layout) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_scrollbar_mode, -1), be_const_func(lvbe_list_set_scrollbar_mode) },
{ be_const_key(focus_btn, -1), be_const_func(lvbe_list_focus_btn) },
{ be_const_key(init, -1), be_const_func(lvbe_list_create) },
{ be_const_key(set_scroll_propagation, 27), be_const_func(lvbe_list_set_scroll_propagation) },
{ be_const_key(get_size, 20), be_const_func(lvbe_list_get_size) },
{ be_const_key(set_anim_time, -1), be_const_func(lvbe_list_set_anim_time) },
{ be_const_key(add_btn, -1), be_const_func(lvbe_list_add_btn) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_list_map,
29
4
);
BE_EXPORT_VARIABLE be_define_const_class(

23
lib/libesp32/Berry/generate/be_fixed_be_class_lv_msgbox.h
View File

@ -1,28 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_msgbox_map) {
{ be_const_key(get_text, 12), be_const_func(lvbe_msgbox_get_text) },
{ be_const_key(set_anim_time, 3), be_const_func(lvbe_msgbox_set_anim_time) },
{ be_const_key(tostring, 0), be_const_func(lvx_tostring) },
{ be_const_key(add_btns, 4), be_const_func(lvbe_msgbox_add_btns) },
{ be_const_key(get_active_btn, -1), be_const_func(lvbe_msgbox_get_active_btn) },
{ be_const_key(stop_auto_close, -1), be_const_func(lvbe_msgbox_stop_auto_close) },
{ be_const_key(start_auto_close, -1), be_const_func(lvbe_msgbox_start_auto_close) },
{ be_const_key(init, -1), be_const_func(lvbe_msgbox_create) },
{ be_const_key(get_btnmatrix, -1), be_const_func(lvbe_msgbox_get_btnmatrix) },
{ be_const_key(get_anim_time, 6), be_const_func(lvbe_msgbox_get_anim_time) },
{ be_const_key(set_text_fmt, -1), be_const_func(lvbe_msgbox_set_text_fmt) },
{ be_const_key(set_recolor, 10), be_const_func(lvbe_msgbox_set_recolor) },
{ be_const_key(get_active_btn_text, -1), be_const_func(lvbe_msgbox_get_active_btn_text) },
{ be_const_key(dot_p, 8), be_const_int(0) },
{ be_const_key(get_recolor, -1), be_const_func(lvbe_msgbox_get_recolor) },
{ be_const_key(set_text, 7), be_const_func(lvbe_msgbox_set_text) },
{ be_const_key(create, -1), be_const_func(lvbe_msgbox_create) },
{ be_const_key(init, 2), be_const_func(lvbe_msgbox_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_msgbox_map,
17
4
);
BE_EXPORT_VARIABLE be_define_const_class(

307
lib/libesp32/Berry/generate/be_fixed_be_class_lv_obj.h
View File

@ -1,314 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_obj_map) {
{ be_const_key(set_style_local_value_line_space, -1), be_const_func(lvbe_obj_set_style_local_value_line_space) },
{ be_const_key(get_style_scale_width, 160), be_const_func(lvbe_obj_get_style_scale_width) },
{ be_const_key(set_style_local_line_opa, 109), be_const_func(lvbe_obj_set_style_local_line_opa) },
{ be_const_key(get_style_border_color, -1), be_const_func(lvbe_obj_get_style_border_color) },
{ be_const_key(set_style_local_scale_border_width, -1), be_const_func(lvbe_obj_set_style_local_scale_border_width) },
{ be_const_key(get_style_shadow_color, 254), be_const_func(lvbe_obj_get_style_shadow_color) },
{ be_const_key(get_style_line_dash_gap, -1), be_const_func(lvbe_obj_get_style_line_dash_gap) },
{ be_const_key(get_height, -1), be_const_func(lvbe_obj_get_height) },
{ be_const_key(get_style_transform_angle, 21), be_const_func(lvbe_obj_get_style_transform_angle) },
{ be_const_key(get_style_image_recolor_opa, 277), be_const_func(lvbe_obj_get_style_image_recolor_opa) },
{ be_const_key(get_group, 129), be_const_func(lvbe_obj_get_group) },
{ be_const_key(set_style_local_text_color, -1), be_const_func(lvbe_obj_set_style_local_text_color) },
{ be_const_key(get_style_pattern_recolor_opa, -1), be_const_func(lvbe_obj_get_style_pattern_recolor_opa) },
{ be_const_key(get_local_style, -1), be_const_func(lvbe_obj_get_local_style) },
{ be_const_key(fade_in, -1), be_const_func(lvbe_obj_fade_in) },
{ be_const_key(get_style_value_line_space, 215), be_const_func(lvbe_obj_get_style_value_line_space) },
{ be_const_key(set_style_local_line_blend_mode, 186), be_const_func(lvbe_obj_set_style_local_line_blend_mode) },
{ be_const_key(get_style_size, -1), be_const_func(lvbe_obj_get_style_size) },
{ be_const_key(set_style_local_shadow_opa, -1), be_const_func(lvbe_obj_set_style_local_shadow_opa) },
{ be_const_key(get_drag_throw, 211), be_const_func(lvbe_obj_get_drag_throw) },
{ be_const_key(get_style_line_width, 38), be_const_func(lvbe_obj_get_style_line_width) },
{ be_const_key(set_drag_throw, 252), be_const_func(lvbe_obj_set_drag_throw) },
{ be_const_key(set_style_local_image_opa, 287), be_const_func(lvbe_obj_set_style_local_image_opa) },
{ be_const_key(init_draw_label_dsc, 60), be_const_func(lvbe_obj_init_draw_label_dsc) },
{ be_const_key(get_style_shadow_ofs_y, -1), be_const_func(lvbe_obj_get_style_shadow_ofs_y) },
{ be_const_key(set_style_local_pattern_blend_mode, 194), be_const_func(lvbe_obj_set_style_local_pattern_blend_mode) },
{ be_const_key(set_style_local_value_blend_mode, 81), be_const_func(lvbe_obj_set_style_local_value_blend_mode) },
{ be_const_key(set_size, -1), be_const_func(lvbe_obj_set_size) },
{ be_const_key(set_focus_parent, -1), be_const_func(lvbe_obj_set_focus_parent) },
{ be_const_key(get_screen, -1), be_const_func(lvbe_obj_get_screen) },
{ be_const_key(get_ext_click_pad_top, -1), be_const_func(lvbe_obj_get_ext_click_pad_top) },
{ be_const_key(set_style_local_value_ofs_y, -1), be_const_func(lvbe_obj_set_style_local_value_ofs_y) },
{ be_const_key(create, -1), be_const_func(lvbe_obj_create) },
{ be_const_key(get_style_pattern_image, -1), be_const_func(lvbe_obj_get_style_pattern_image) },
{ be_const_key(get_style_line_opa, -1), be_const_func(lvbe_obj_get_style_line_opa) },
{ be_const_key(set_state, 180), be_const_func(lvbe_obj_set_state) },
{ be_const_key(get_style_outline_opa, 22), be_const_func(lvbe_obj_get_style_outline_opa) },
{ be_const_key(set_style_local_transition_path, 52), be_const_func(lvbe_obj_set_style_local_transition_path) },
{ be_const_key(set_style_local_bg_main_stop, -1), be_const_func(lvbe_obj_set_style_local_bg_main_stop) },
{ be_const_key(get_inner_coords, 301), be_const_func(lvbe_obj_get_inner_coords) },
{ be_const_key(set_style_local_scale_end_border_width, -1), be_const_func(lvbe_obj_set_style_local_scale_end_border_width) },
{ be_const_key(set_style_local_pattern_repeat, 62), be_const_func(lvbe_obj_set_style_local_pattern_repeat) },
{ be_const_key(set_style_local_bg_color, 64), be_const_func(lvbe_obj_set_style_local_bg_color) },
{ be_const_key(set_click, 268), be_const_func(lvbe_obj_set_click) },
{ be_const_key(get_style_text_letter_space, 245), be_const_func(lvbe_obj_get_style_text_letter_space) },
{ be_const_key(set_style_local_pad_top, -1), be_const_func(lvbe_obj_set_style_local_pad_top) },
{ be_const_key(set_style_local_border_width, -1), be_const_func(lvbe_obj_set_style_local_border_width) },
{ be_const_key(get_style_transform_height, 184), be_const_func(lvbe_obj_get_style_transform_height) },
{ be_const_key(get_ext_click_pad_bottom, -1), be_const_func(lvbe_obj_get_ext_click_pad_bottom) },
{ be_const_key(get_drag_parent, -1), be_const_func(lvbe_obj_get_drag_parent) },
{ be_const_key(get_style_line_dash_width, 266), be_const_func(lvbe_obj_get_style_line_dash_width) },
{ be_const_key(get_style_bg_grad_stop, -1), be_const_func(lvbe_obj_get_style_bg_grad_stop) },
{ be_const_key(move_background, -1), be_const_func(lvbe_obj_move_background) },
{ be_const_key(get_style_line_color, -1), be_const_func(lvbe_obj_get_style_line_color) },
{ be_const_key(get_style_margin_right, -1), be_const_func(lvbe_obj_get_style_margin_right) },
{ be_const_key(get_style_image_recolor, -1), be_const_func(lvbe_obj_get_style_image_recolor) },
{ be_const_key(add_state, -1), be_const_func(lvbe_obj_add_state) },
{ be_const_key(set_design_cb, -1), be_const_func(lvbe_obj_set_design_cb) },
{ be_const_key(set_style_local_bg_blend_mode, -1), be_const_func(lvbe_obj_set_style_local_bg_blend_mode) },
{ be_const_key(get_style_shadow_blend_mode, -1), be_const_func(lvbe_obj_get_style_shadow_blend_mode) },
{ be_const_key(set_style_local_transition_delay, 195), be_const_func(lvbe_obj_set_style_local_transition_delay) },
{ be_const_key(align_x, 93), be_const_func(lvbe_obj_align_x) },
{ be_const_key(get_style_bg_main_stop, 168), be_const_func(lvbe_obj_get_style_bg_main_stop) },
{ be_const_key(get_style_border_width, 74), be_const_func(lvbe_obj_get_style_border_width) },
{ be_const_key(get_style_border_blend_mode, -1), be_const_func(lvbe_obj_get_style_border_blend_mode) },
{ be_const_key(clear_protect, -1), be_const_func(lvbe_obj_clear_protect) },
{ be_const_key(move_foreground, -1), be_const_func(lvbe_obj_move_foreground) },
{ be_const_key(get_style_bg_grad_dir, -1), be_const_func(lvbe_obj_get_style_bg_grad_dir) },
{ be_const_key(set_style_local_transition_prop_2, -1), be_const_func(lvbe_obj_set_style_local_transition_prop_2) },
{ be_const_key(set_style_local_pad_inner, -1), be_const_func(lvbe_obj_set_style_local_pad_inner) },
{ be_const_key(get_style_border_opa, -1), be_const_func(lvbe_obj_get_style_border_opa) },
{ be_const_key(set_style_local_border_opa, -1), be_const_func(lvbe_obj_set_style_local_border_opa) },
{ be_const_key(set_style_local_line_color, -1), be_const_func(lvbe_obj_set_style_local_line_color) },
{ be_const_key(get_style_line_blend_mode, -1), be_const_func(lvbe_obj_get_style_line_blend_mode) },
{ be_const_key(get_style_text_sel_color, -1), be_const_func(lvbe_obj_get_style_text_sel_color) },
{ be_const_key(set_style_local_shadow_ofs_x, -1), be_const_func(lvbe_obj_set_style_local_shadow_ofs_x) },
{ be_const_key(set_style_local_radius, 267), be_const_func(lvbe_obj_set_style_local_radius) },
{ be_const_key(init_draw_line_dsc, -1), be_const_func(lvbe_obj_init_draw_line_dsc) },
{ be_const_key(is_focused, -1), be_const_func(lvbe_obj_is_focused) },
{ be_const_key(get_adv_hittest, 116), be_const_func(lvbe_obj_get_adv_hittest) },
{ be_const_key(set_style_local_text_letter_space, -1), be_const_func(lvbe_obj_set_style_local_text_letter_space) },
{ be_const_key(get_click, -1), be_const_func(lvbe_obj_get_click) },
{ be_const_key(get_style_shadow_spread, -1), be_const_func(lvbe_obj_get_style_shadow_spread) },
{ be_const_key(set_style_local_outline_pad, -1), be_const_func(lvbe_obj_set_style_local_outline_pad) },
{ be_const_key(set_event_cb, 131), be_const_func(lvbe_obj_set_event_cb) },
{ be_const_key(realign, 94), be_const_func(lvbe_obj_realign) },
{ be_const_key(set_parent_event, 191), be_const_func(lvbe_obj_set_parent_event) },
{ be_const_key(get_style_value_ofs_y, -1), be_const_func(lvbe_obj_get_style_value_ofs_y) },
{ be_const_key(get_focus_parent, 117), be_const_func(lvbe_obj_get_focus_parent) },
{ be_const_key(clean, 170), be_const_func(lvbe_obj_clean) },
{ be_const_key(set_ext_click_area, -1), be_const_func(lvbe_obj_set_ext_click_area) },
{ be_const_key(get_style_pattern_recolor, 133), be_const_func(lvbe_obj_get_style_pattern_recolor) },
{ be_const_key(get_coords, -1), be_const_func(lvbe_obj_get_coords) },
{ be_const_key(get_width_margin, -1), be_const_func(lvbe_obj_get_width_margin) },
{ be_const_key(set_gesture_parent, 130), be_const_func(lvbe_obj_set_gesture_parent) },
{ be_const_key(get_ext_click_pad_right, 57), be_const_func(lvbe_obj_get_ext_click_pad_right) },
{ be_const_key(set_style_local_clip_corner, -1), be_const_func(lvbe_obj_set_style_local_clip_corner) },
{ be_const_key(invalidate_area, 236), be_const_func(lvbe_obj_invalidate_area) },
{ be_const_key(is_point_on_coords, -1), be_const_func(lvbe_obj_is_point_on_coords) },
{ be_const_key(set_style_local_bg_grad_stop, -1), be_const_func(lvbe_obj_set_style_local_bg_grad_stop) },
{ be_const_key(get_style_pad_bottom, 119), be_const_func(lvbe_obj_get_style_pad_bottom) },
{ be_const_key(set_style_local_transform_angle, -1), be_const_func(lvbe_obj_set_style_local_transform_angle) },
{ be_const_key(get_style_pad_right, 67), be_const_func(lvbe_obj_get_style_pad_right) },
{ be_const_key(set_style_local_transform_height, -1), be_const_func(lvbe_obj_set_style_local_transform_height) },
{ be_const_key(set_style_local_transition_prop_1, -1), be_const_func(lvbe_obj_set_style_local_transition_prop_1) },
{ be_const_key(set_style_local_pad_bottom, -1), be_const_func(lvbe_obj_set_style_local_pad_bottom) },
{ be_const_key(set_style_local_scale_end_color, 141), be_const_func(lvbe_obj_set_style_local_scale_end_color) },
{ be_const_key(get_drag_dir, -1), be_const_func(lvbe_obj_get_drag_dir) },
{ be_const_key(get_child_back, -1), be_const_func(lvbe_obj_get_child_back) },
{ be_const_key(set_style_local_outline_color, 138), be_const_func(lvbe_obj_set_style_local_outline_color) },
{ be_const_key(set_adv_hittest, -1), be_const_func(lvbe_obj_set_adv_hittest) },
{ be_const_key(init_draw_rect_dsc, 82), be_const_func(lvbe_obj_init_draw_rect_dsc) },
{ be_const_key(get_parent_event, -1), be_const_func(lvbe_obj_get_parent_event) },
{ be_const_key(get_style_transition_prop_4, -1), be_const_func(lvbe_obj_get_style_transition_prop_4) },
{ be_const_key(set_style_local_pattern_image, 166), be_const_func(lvbe_obj_set_style_local_pattern_image) },
{ be_const_key(set_style_local_margin_right, -1), be_const_func(lvbe_obj_set_style_local_margin_right) },
{ be_const_key(get_hidden, -1), be_const_func(lvbe_obj_get_hidden) },
{ be_const_key(get_user_data, 169), be_const_func(lvbe_obj_get_user_data) },
{ be_const_key(get_style_pattern_blend_mode, 136), be_const_func(lvbe_obj_get_style_pattern_blend_mode) },
{ be_const_key(get_style_transition_prop_6, -1), be_const_func(lvbe_obj_get_style_transition_prop_6) },
{ be_const_key(get_style_value_letter_space, 33), be_const_func(lvbe_obj_get_style_value_letter_space) },
{ be_const_key(get_style_shadow_ofs_x, 173), be_const_func(lvbe_obj_get_style_shadow_ofs_x) },
{ be_const_key(get_style_value_blend_mode, -1), be_const_func(lvbe_obj_get_style_value_blend_mode) },
{ be_const_key(get_height_fit, -1), be_const_func(lvbe_obj_get_height_fit) },
{ be_const_key(set_style_local_shadow_blend_mode, -1), be_const_func(lvbe_obj_set_style_local_shadow_blend_mode) },
{ be_const_key(area_is_visible, -1), be_const_func(lvbe_obj_area_is_visible) },
{ be_const_key(set_style_local_size, -1), be_const_func(lvbe_obj_set_style_local_size) },
{ be_const_key(set_style_local_bg_grad_color, -1), be_const_func(lvbe_obj_set_style_local_bg_grad_color) },
{ be_const_key(get_style_transition_delay, -1), be_const_func(lvbe_obj_get_style_transition_delay) },
{ be_const_key(get_type, -1), be_const_func(lvbe_obj_get_type) },
{ be_const_key(get_protect, 265), be_const_func(lvbe_obj_get_protect) },
{ be_const_key(get_auto_realign, -1), be_const_func(lvbe_obj_get_auto_realign) },
{ be_const_key(get_style_clip_corner, -1), be_const_func(lvbe_obj_get_style_clip_corner) },
{ be_const_key(get_style_transition_time, -1), be_const_func(lvbe_obj_get_style_transition_time) },
{ be_const_key(get_style_margin_left, -1), be_const_func(lvbe_obj_get_style_margin_left) },
{ be_const_key(get_height_margin, 233), be_const_func(lvbe_obj_get_height_margin) },
{ be_const_key(get_style_image_opa, -1), be_const_func(lvbe_obj_get_style_image_opa) },
{ be_const_key(set_style_local_margin_left, 257), be_const_func(lvbe_obj_set_style_local_margin_left) },
{ be_const_key(get_width_fit, -1), be_const_func(lvbe_obj_get_width_fit) },
{ be_const_key(get_style_margin_top, 147), be_const_func(lvbe_obj_get_style_margin_top) },
{ be_const_key(set_style_local_value_align, -1), be_const_func(lvbe_obj_set_style_local_value_align) },
{ be_const_key(get_width_grid, 29), be_const_func(lvbe_obj_get_width_grid) },
{ be_const_key(get_style_line_rounded, -1), be_const_func(lvbe_obj_get_style_line_rounded) },
{ be_const_key(get_ext_attr, -1), be_const_func(lvbe_obj_get_ext_attr) },
{ be_const_key(set_style_local_line_rounded, -1), be_const_func(lvbe_obj_set_style_local_line_rounded) },
{ be_const_key(set_style_local_outline_opa, -1), be_const_func(lvbe_obj_set_style_local_outline_opa) },
{ be_const_key(del, 218), be_const_func(lvbe_obj_del) },
{ be_const_key(get_style_outline_color, 177), be_const_func(lvbe_obj_get_style_outline_color) },
{ be_const_key(refresh_ext_draw_pad, 285), be_const_func(lvbe_obj_refresh_ext_draw_pad) },
{ be_const_key(remove_style, 227), be_const_func(lvbe_obj_remove_style) },
{ be_const_key(allocate_ext_attr, -1), be_const_func(lvbe_obj_allocate_ext_attr) },
{ be_const_key(invalidate, -1), be_const_func(lvbe_obj_invalidate) },
{ be_const_key(set_drag_parent, -1), be_const_func(lvbe_obj_set_drag_parent) },
{ be_const_key(set_style_local_transition_prop_6, -1), be_const_func(lvbe_obj_set_style_local_transition_prop_6) },
{ be_const_key(init, 2), be_const_func(lvbe_obj_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_style_local_bg_opa, 159), be_const_func(lvbe_obj_set_style_local_bg_opa) },
{ be_const_key(get_style_margin_bottom, 28), be_const_func(lvbe_obj_get_style_margin_bottom) },
{ be_const_key(get_parent, -1), be_const_func(lvbe_obj_get_parent) },
{ be_const_key(align_y, -1), be_const_func(lvbe_obj_align_y) },
{ be_const_key(set_style_local_scale_end_line_width, -1), be_const_func(lvbe_obj_set_style_local_scale_end_line_width) },
{ be_const_key(get_style_image_blend_mode, -1), be_const_func(lvbe_obj_get_style_image_blend_mode) },
{ be_const_key(finish_transitions, -1), be_const_func(lvbe_obj_finish_transitions) },
{ be_const_key(remove_style_local_prop, -1), be_const_func(lvbe_obj_remove_style_local_prop) },
{ be_const_key(get_style_value_opa, 140), be_const_func(lvbe_obj_get_style_value_opa) },
{ be_const_key(get_style_value_str, -1), be_const_func(lvbe_obj_get_style_value_str) },
{ be_const_key(set_style_local_value_letter_space, 104), be_const_func(lvbe_obj_set_style_local_value_letter_space) },
{ be_const_key(set_pos, -1), be_const_func(lvbe_obj_set_pos) },
{ be_const_key(set_drag_dir, -1), be_const_func(lvbe_obj_set_drag_dir) },
{ be_const_key(get_style_bg_blend_mode, 59), be_const_func(lvbe_obj_get_style_bg_blend_mode) },
{ be_const_key(get_style_transition_prop_3, 262), be_const_func(lvbe_obj_get_style_transition_prop_3) },
{ be_const_key(set_width, -1), be_const_func(lvbe_obj_set_width) },
{ be_const_key(get_height_grid, -1), be_const_func(lvbe_obj_get_height_grid) },
{ be_const_key(set_style_local_pattern_opa, 302), be_const_func(lvbe_obj_set_style_local_pattern_opa) },
{ be_const_key(get_child, -1), be_const_func(lvbe_obj_get_child) },
{ be_const_key(set_base_dir, -1), be_const_func(lvbe_obj_set_base_dir) },
{ be_const_key(set_style_local_outline_blend_mode, -1), be_const_func(lvbe_obj_set_style_local_outline_blend_mode) },
{ be_const_key(count_children, 174), be_const_func(lvbe_obj_count_children) },
{ be_const_key(set_style_local_shadow_spread, -1), be_const_func(lvbe_obj_set_style_local_shadow_spread) },
{ be_const_key(is_visible, -1), be_const_func(lvbe_obj_is_visible) },
{ be_const_key(get_style_scale_end_border_width, 251), be_const_func(lvbe_obj_get_style_scale_end_border_width) },
{ be_const_key(get_focused_obj, -1), be_const_func(lvbe_obj_get_focused_obj) },
{ be_const_key(get_style_value_align, -1), be_const_func(lvbe_obj_get_style_value_align) },
{ be_const_key(get_style_bg_grad_color, 48), be_const_func(lvbe_obj_get_style_bg_grad_color) },
{ be_const_key(set_style_local_image_recolor_opa, -1), be_const_func(lvbe_obj_set_style_local_image_recolor_opa) },
{ be_const_key(get_style_outline_pad, -1), be_const_func(lvbe_obj_get_style_outline_pad) },
{ be_const_key(get_style_transition_prop_2, -1), be_const_func(lvbe_obj_get_style_transition_prop_2) },
{ be_const_key(set_width_fit, -1), be_const_func(lvbe_obj_set_width_fit) },
{ be_const_key(set_style_local_shadow_color, 234), be_const_func(lvbe_obj_set_style_local_shadow_color) },
{ be_const_key(set_style_local_scale_width, -1), be_const_func(lvbe_obj_set_style_local_scale_width) },
{ be_const_key(get_top, -1), be_const_func(lvbe_obj_get_top) },
{ be_const_key(get_style_pad_inner, -1), be_const_func(lvbe_obj_get_style_pad_inner) },
{ be_const_key(set_style_local_margin_bottom, -1), be_const_func(lvbe_obj_set_style_local_margin_bottom) },
{ be_const_key(get_style_outline_blend_mode, 77), be_const_func(lvbe_obj_get_style_outline_blend_mode) },
{ be_const_key(set_style_local_line_dash_width, 70), be_const_func(lvbe_obj_set_style_local_line_dash_width) },
{ be_const_key(get_x, -1), be_const_func(lvbe_obj_get_x) },
{ be_const_key(set_auto_realign, -1), be_const_func(lvbe_obj_set_auto_realign) },
{ be_const_key(set_style_local_border_color, -1), be_const_func(lvbe_obj_set_style_local_border_color) },
{ be_const_key(get_style_transition_prop_5, -1), be_const_func(lvbe_obj_get_style_transition_prop_5) },
{ be_const_key(set_style_local_pattern_recolor_opa, -1), be_const_func(lvbe_obj_set_style_local_pattern_recolor_opa) },
{ be_const_key(add_protect, -1), be_const_func(lvbe_obj_add_protect) },
{ be_const_key(set_style_local_pad_right, 190), be_const_func(lvbe_obj_set_style_local_pad_right) },
{ be_const_key(get_base_dir, -1), be_const_func(lvbe_obj_get_base_dir) },
{ be_const_key(is_protected, -1), be_const_func(lvbe_obj_is_protected) },
{ be_const_key(get_style_radius, -1), be_const_func(lvbe_obj_get_style_radius) },
{ be_const_key(get_style_border_post, 126), be_const_func(lvbe_obj_get_style_border_post) },
{ be_const_key(get_style_text_line_space, 235), be_const_func(lvbe_obj_get_style_text_line_space) },
{ be_const_key(set_style_local_opa_scale, -1), be_const_func(lvbe_obj_set_style_local_opa_scale) },
{ be_const_key(set_signal_cb, -1), be_const_func(lvbe_obj_set_signal_cb) },
{ be_const_key(set_style_local_image_blend_mode, 124), be_const_func(lvbe_obj_set_style_local_image_blend_mode) },
{ be_const_key(set_drag, 181), be_const_func(lvbe_obj_set_drag) },
{ be_const_key(set_style_local_line_width, -1), be_const_func(lvbe_obj_set_style_local_line_width) },
{ be_const_key(set_style_local_text_sel_color, 208), be_const_func(lvbe_obj_set_style_local_text_sel_color) },
{ be_const_key(get_gesture_parent, 54), be_const_func(lvbe_obj_get_gesture_parent) },
{ be_const_key(get_draw_rect_ext_pad_size, -1), be_const_func(lvbe_obj_get_draw_rect_ext_pad_size) },
{ be_const_key(set_style_local_text_opa, -1), be_const_func(lvbe_obj_set_style_local_text_opa) },
{ be_const_key(refresh_style, -1), be_const_func(lvbe_obj_refresh_style) },
{ be_const_key(hittest, 183), be_const_func(lvbe_obj_hittest) },
{ be_const_key(clear_state, -1), be_const_func(lvbe_obj_clear_state) },
{ be_const_key(set_style_local_value_color, -1), be_const_func(lvbe_obj_set_style_local_value_color) },
{ be_const_key(get_style_scale_grad_color, 13), be_const_func(lvbe_obj_get_style_scale_grad_color) },
{ be_const_key(reset_style_list, 12), be_const_func(lvbe_obj_reset_style_list) },
{ be_const_key(set_width_margin, 19), be_const_func(lvbe_obj_set_width_margin) },
{ be_const_key(get_style_bg_opa, -1), be_const_func(lvbe_obj_get_style_bg_opa) },
{ be_const_key(get_style_scale_border_width, -1), be_const_func(lvbe_obj_get_style_scale_border_width) },
{ be_const_key(align, -1), be_const_func(lvbe_obj_align) },
{ be_const_key(align_mid, -1), be_const_func(lvbe_obj_align_mid) },
{ be_const_key(set_style_local_border_side, -1), be_const_func(lvbe_obj_set_style_local_border_side) },
{ be_const_key(set_style_local_transition_time, -1), be_const_func(lvbe_obj_set_style_local_transition_time) },
{ be_const_key(init, 217), be_const_func(lvbe_obj_create) },
{ be_const_key(set_style_local_text_font, -1), be_const_func(lvbe_obj_set_style_local_text_font) },
{ be_const_key(set_style_local_text_sel_bg_color, -1), be_const_func(lvbe_obj_set_style_local_text_sel_bg_color) },
{ be_const_key(get_y, 151), be_const_func(lvbe_obj_get_y) },
{ be_const_key(get_style_border_side, 4), be_const_func(lvbe_obj_get_style_border_side) },
{ be_const_key(set_hidden, -1), be_const_func(lvbe_obj_set_hidden) },
{ be_const_key(set_style_local_value_opa, 244), be_const_func(lvbe_obj_set_style_local_value_opa) },
{ be_const_key(set_style_local_margin_top, -1), be_const_func(lvbe_obj_set_style_local_margin_top) },
{ be_const_key(set_style_local_value_str, -1), be_const_func(lvbe_obj_set_style_local_value_str) },
{ be_const_key(set_style_local_value_ofs_x, 187), be_const_func(lvbe_obj_set_style_local_value_ofs_x) },
{ be_const_key(get_style_text_color, 51), be_const_func(lvbe_obj_get_style_text_color) },
{ be_const_key(get_style_pattern_opa, -1), be_const_func(lvbe_obj_get_style_pattern_opa) },
{ be_const_key(clean_style_list, -1), be_const_func(lvbe_obj_clean_style_list) },
{ be_const_key(set_style_local_text_blend_mode, -1), be_const_func(lvbe_obj_set_style_local_text_blend_mode) },
{ be_const_key(get_style_transform_width, -1), be_const_func(lvbe_obj_get_style_transform_width) },
{ be_const_key(set_style_local_transform_zoom, 239), be_const_func(lvbe_obj_set_style_local_transform_zoom) },
{ be_const_key(set_style_local_scale_grad_color, 188), be_const_func(lvbe_obj_set_style_local_scale_grad_color) },
{ be_const_key(set_style_local_transition_prop_4, -1), be_const_func(lvbe_obj_set_style_local_transition_prop_4) },
{ be_const_key(set_style_local_pattern_recolor, -1), be_const_func(lvbe_obj_set_style_local_pattern_recolor) },
{ be_const_key(set_style_local_shadow_width, -1), be_const_func(lvbe_obj_set_style_local_shadow_width) },
{ be_const_key(get_style_opa_scale, -1), be_const_func(lvbe_obj_get_style_opa_scale) },
{ be_const_key(set_style_local_bg_grad_dir, -1), be_const_func(lvbe_obj_set_style_local_bg_grad_dir) },
{ be_const_key(set_top, 269), be_const_func(lvbe_obj_set_top) },
{ be_const_key(set_y, -1), be_const_func(lvbe_obj_set_y) },
{ be_const_key(get_width, -1), be_const_func(lvbe_obj_get_width) },
{ be_const_key(set_style_local_border_post, -1), be_const_func(lvbe_obj_set_style_local_border_post) },
{ be_const_key(get_style_value_color, -1), be_const_func(lvbe_obj_get_style_value_color) },
{ be_const_key(get_style_text_opa, -1), be_const_func(lvbe_obj_get_style_text_opa) },
{ be_const_key(set_style_local_pad_left, 295), be_const_func(lvbe_obj_set_style_local_pad_left) },
{ be_const_key(get_style_shadow_width, -1), be_const_func(lvbe_obj_get_style_shadow_width) },
{ be_const_key(report_style_mod, -1), be_const_func(lvbe_obj_report_style_mod) },
{ be_const_key(get_style_pad_top, 110), be_const_func(lvbe_obj_get_style_pad_top) },
{ be_const_key(set_style_local_line_dash_gap, -1), be_const_func(lvbe_obj_set_style_local_line_dash_gap) },
{ be_const_key(get_style_scale_end_line_width, 201), be_const_func(lvbe_obj_get_style_scale_end_line_width) },
{ be_const_key(del_anim_ready_cb, -1), be_const_func(lvbe_obj_del_anim_ready_cb) },
{ be_const_key(set_style_local_transform_width, -1), be_const_func(lvbe_obj_set_style_local_transform_width) },
{ be_const_key(get_style_bg_color, -1), be_const_func(lvbe_obj_get_style_bg_color) },
{ be_const_key(get_style_text_blend_mode, -1), be_const_func(lvbe_obj_get_style_text_blend_mode) },
{ be_const_key(align_mid_x, -1), be_const_func(lvbe_obj_align_mid_x) },
{ be_const_key(get_style_outline_width, -1), be_const_func(lvbe_obj_get_style_outline_width) },
{ be_const_key(get_ext_draw_pad, -1), be_const_func(lvbe_obj_get_ext_draw_pad) },
{ be_const_key(dot_p, 278), be_const_int(0) },
{ be_const_key(get_style_pattern_repeat, -1), be_const_func(lvbe_obj_get_style_pattern_repeat) },
{ be_const_key(set_style_local_image_recolor, -1), be_const_func(lvbe_obj_set_style_local_image_recolor) },
{ be_const_key(init_draw_img_dsc, -1), be_const_func(lvbe_obj_init_draw_img_dsc) },
{ be_const_key(set_style_local_border_blend_mode, 148), be_const_func(lvbe_obj_set_style_local_border_blend_mode) },
{ be_const_key(set_style_local_transition_prop_3, 72), be_const_func(lvbe_obj_set_style_local_transition_prop_3) },
{ be_const_key(get_state, -1), be_const_func(lvbe_obj_get_state) },
{ be_const_key(set_x, -1), be_const_func(lvbe_obj_set_x) },
{ be_const_key(set_style_local_text_decor, -1), be_const_func(lvbe_obj_set_style_local_text_decor) },
{ be_const_key(set_style_local_transition_prop_5, -1), be_const_func(lvbe_obj_set_style_local_transition_prop_5) },
{ be_const_key(set_height, 172), be_const_func(lvbe_obj_set_height) },
{ be_const_key(del_async, 213), be_const_func(lvbe_obj_del_async) },
{ be_const_key(set_style_local_shadow_ofs_y, -1), be_const_func(lvbe_obj_set_style_local_shadow_ofs_y) },
{ be_const_key(get_style_transition_prop_1, -1), be_const_func(lvbe_obj_get_style_transition_prop_1) },
{ be_const_key(count_children_recursive, -1), be_const_func(lvbe_obj_count_children_recursive) },
{ be_const_key(get_style_pad_left, -1), be_const_func(lvbe_obj_get_style_pad_left) },
{ be_const_key(set_user_data, -1), be_const_func(lvbe_obj_set_user_data) },
{ be_const_key(set_height_margin, 288), be_const_func(lvbe_obj_set_height_margin) },
{ be_const_key(set_style_local_text_line_space, -1), be_const_func(lvbe_obj_set_style_local_text_line_space) },
{ be_const_key(get_style_scale_end_color, -1), be_const_func(lvbe_obj_get_style_scale_end_color) },
{ be_const_key(set_height_fit, -1), be_const_func(lvbe_obj_set_height_fit) },
{ be_const_key(get_style_transform_zoom, 283), be_const_func(lvbe_obj_get_style_transform_zoom) },
{ be_const_key(handle_get_type_signal, -1), be_const_func(lvbe_obj_handle_get_type_signal) },
{ be_const_key(fade_out, -1), be_const_func(lvbe_obj_fade_out) },
{ be_const_key(get_style_value_ofs_x, 125), be_const_func(lvbe_obj_get_style_value_ofs_x) },
{ be_const_key(get_ext_click_pad_left, 113), be_const_func(lvbe_obj_get_ext_click_pad_left) },
{ be_const_key(align_mid_y, -1), be_const_func(lvbe_obj_align_mid_y) },
{ be_const_key(get_drag, -1), be_const_func(lvbe_obj_get_drag) },
{ be_const_key(set_style_local_value_font, 17), be_const_func(lvbe_obj_set_style_local_value_font) },
{ be_const_key(get_style_shadow_opa, -1), be_const_func(lvbe_obj_get_style_shadow_opa) },
{ be_const_key(set_parent, -1), be_const_func(lvbe_obj_set_parent) },
{ be_const_key(add_style, 73), be_const_func(lvbe_obj_add_style) },
{ be_const_key(set_style_local_outline_width, -1), be_const_func(lvbe_obj_set_style_local_outline_width) },
{ be_const_key(get_style_text_sel_bg_color, -1), be_const_func(lvbe_obj_get_style_text_sel_bg_color) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_obj_map,
303
4
);
BE_EXPORT_VARIABLE be_define_const_class(

10
lib/libesp32/Berry/generate/be_fixed_be_class_lv_objmask.h
View File

@ -1,17 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_objmask_map) {
{ be_const_key(init, 2), be_const_func(lvbe_objmask_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(tostring, 0), be_const_func(lvx_tostring) },
{ be_const_key(remove_mask, -1), be_const_func(lvbe_objmask_remove_mask) },
{ be_const_key(init, -1), be_const_func(lvbe_objmask_create) },
{ be_const_key(create, -1), be_const_func(lvbe_objmask_create) },
{ be_const_key(update_mask, 4), be_const_func(lvbe_objmask_update_mask) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_objmask_map,
6
4
);
BE_EXPORT_VARIABLE be_define_const_class(

40
lib/libesp32/Berry/generate/be_fixed_be_class_lv_page.h
View File

@ -1,47 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_page_map) {
{ be_const_key(on_edge, -1), be_const_func(lvbe_page_on_edge) },
{ be_const_key(glue_obj, -1), be_const_func(lvbe_page_glue_obj) },
{ be_const_key(scroll_ver, -1), be_const_func(lvbe_page_scroll_ver) },
{ be_const_key(get_height_fit, -1), be_const_func(lvbe_page_get_height_fit) },
{ be_const_key(get_scrollbar_mode, 16), be_const_func(lvbe_page_get_scrollbar_mode) },
{ be_const_key(create, 29), be_const_func(lvbe_page_create) },
{ be_const_key(get_scrl_height, -1), be_const_func(lvbe_page_get_scrl_height) },
{ be_const_key(set_scrl_layout, -1), be_const_func(lvbe_page_set_scrl_layout) },
{ be_const_key(set_edge_flash, -1), be_const_func(lvbe_page_set_edge_flash) },
{ be_const_key(get_height_grid, -1), be_const_func(lvbe_page_get_height_grid) },
{ be_const_key(get_scrl_fit_bottom, 1), be_const_func(lvbe_page_get_scrl_fit_bottom) },
{ be_const_key(get_scrl_layout, 18), be_const_func(lvbe_page_get_scrl_layout) },
{ be_const_key(get_scrl_fit_left, 33), be_const_func(lvbe_page_get_scrl_fit_left) },
{ be_const_key(get_width_grid, -1), be_const_func(lvbe_page_get_width_grid) },
{ be_const_key(set_scrl_height, 6), be_const_func(lvbe_page_set_scrl_height) },
{ be_const_key(init, -1), be_const_func(lvbe_page_create) },
{ be_const_key(get_edge_flash, -1), be_const_func(lvbe_page_get_edge_flash) },
{ be_const_key(focus, -1), be_const_func(lvbe_page_focus) },
{ be_const_key(set_anim_time, -1), be_const_func(lvbe_page_set_anim_time) },
{ be_const_key(init, 2), be_const_func(lvbe_page_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_width_fit, 22), be_const_func(lvbe_page_get_width_fit) },
{ be_const_key(get_scrollable, 34), be_const_func(lvbe_page_get_scrollable) },
{ be_const_key(get_scroll_propagation, -1), be_const_func(lvbe_page_get_scroll_propagation) },
{ be_const_key(get_scrl_width, -1), be_const_func(lvbe_page_get_scrl_width) },
{ be_const_key(set_scrollbar_mode, 9), be_const_func(lvbe_page_set_scrollbar_mode) },
{ be_const_key(tostring, 27), be_const_func(lvx_tostring) },
{ be_const_key(clean, -1), be_const_func(lvbe_page_clean) },
{ be_const_key(set_scrollable_fit2, -1), be_const_func(lvbe_page_set_scrollable_fit2) },
{ be_const_key(set_scroll_propagation, 32), be_const_func(lvbe_page_set_scroll_propagation) },
{ be_const_key(set_scrollable_fit, -1), be_const_func(lvbe_page_set_scrollable_fit) },
{ be_const_key(scroll_hor, -1), be_const_func(lvbe_page_scroll_hor) },
{ be_const_key(get_anim_time, 17), be_const_func(lvbe_page_get_anim_time) },
{ be_const_key(start_edge_flash, -1), be_const_func(lvbe_page_start_edge_flash) },
{ be_const_key(get_scrl_fit_top, -1), be_const_func(lvbe_page_get_scrl_fit_top) },
{ be_const_key(get_scrl_fit_right, -1), be_const_func(lvbe_page_get_scrl_fit_right) },
{ be_const_key(set_scrl_width, -1), be_const_func(lvbe_page_set_scrl_width) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_page_map,
36
4
);
BE_EXPORT_VARIABLE be_define_const_class(

19
lib/libesp32/Berry/generate/be_fixed_be_class_lv_roller.h
View File

@ -1,28 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_roller_map) {
{ be_const_key(set_options, -1), be_const_func(lvbe_roller_set_options) },
{ be_const_key(get_align, 6), be_const_func(lvbe_roller_get_align) },
{ be_const_key(set_visible_row_count, 12), be_const_func(lvbe_roller_set_visible_row_count) },
{ be_const_key(get_selected_str, -1), be_const_func(lvbe_roller_get_selected_str) },
{ be_const_key(get_selected, -1), be_const_func(lvbe_roller_get_selected) },
{ be_const_key(set_selected, -1), be_const_func(lvbe_roller_set_selected) },
{ be_const_key(set_anim_time, 0), be_const_func(lvbe_roller_set_anim_time) },
{ be_const_key(set_align, -1), be_const_func(lvbe_roller_set_align) },
{ be_const_key(get_auto_fit, -1), be_const_func(lvbe_roller_get_auto_fit) },
{ be_const_key(set_auto_fit, 10), be_const_func(lvbe_roller_set_auto_fit) },
{ be_const_key(get_anim_time, -1), be_const_func(lvbe_roller_get_anim_time) },
{ be_const_key(get_option_cnt, 5), be_const_func(lvbe_roller_get_option_cnt) },
{ be_const_key(init, 2), be_const_func(lvbe_roller_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(get_options, 14), be_const_func(lvbe_roller_get_options) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(init, 7), be_const_func(lvbe_roller_create) },
{ be_const_key(create, -1), be_const_func(lvbe_roller_create) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_roller_map,
17
4
);
BE_EXPORT_VARIABLE be_define_const_class(

20
lib/libesp32/Berry/generate/be_fixed_be_class_lv_slider.h
View File

@ -1,27 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_slider_map) {
{ be_const_key(get_type, -1), be_const_func(lvbe_slider_get_type) },
{ be_const_key(get_anim_time, -1), be_const_func(lvbe_slider_get_anim_time) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(init, 10), be_const_func(lvbe_slider_create) },
{ be_const_key(is_dragged, -1), be_const_func(lvbe_slider_is_dragged) },
{ be_const_key(init, 2), be_const_func(lvbe_slider_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(create, -1), be_const_func(lvbe_slider_create) },
{ be_const_key(get_value, -1), be_const_func(lvbe_slider_get_value) },
{ be_const_key(get_max_value, -1), be_const_func(lvbe_slider_get_max_value) },
{ be_const_key(set_range, 7), be_const_func(lvbe_slider_set_range) },
{ be_const_key(set_anim_time, 2), be_const_func(lvbe_slider_set_anim_time) },
{ be_const_key(get_left_value, -1), be_const_func(lvbe_slider_get_left_value) },
{ be_const_key(set_type, -1), be_const_func(lvbe_slider_set_type) },
{ be_const_key(set_value, 6), be_const_func(lvbe_slider_set_value) },
{ be_const_key(get_min_value, -1), be_const_func(lvbe_slider_get_min_value) },
{ be_const_key(set_left_value, 1), be_const_func(lvbe_slider_set_left_value) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_slider_map,
16
4
);
BE_EXPORT_VARIABLE be_define_const_class(

21
lib/libesp32/Berry/generate/be_fixed_be_class_lv_spinbox.h
View File

@ -1,28 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_spinbox_map) {
{ be_const_key(get_value, 6), be_const_func(lvbe_spinbox_get_value) },
{ be_const_key(decrement, -1), be_const_func(lvbe_spinbox_decrement) },
{ be_const_key(tostring, 4), be_const_func(lvx_tostring) },
{ be_const_key(set_value, -1), be_const_func(lvbe_spinbox_set_value) },
{ be_const_key(step_next, 11), be_const_func(lvbe_spinbox_step_next) },
{ be_const_key(init, -1), be_const_func(lvbe_spinbox_create) },
{ be_const_key(set_rollover, -1), be_const_func(lvbe_spinbox_set_rollover) },
{ be_const_key(get_step, -1), be_const_func(lvbe_spinbox_get_step) },
{ be_const_key(set_padding_left, -1), be_const_func(lvbe_spinbox_set_padding_left) },
{ be_const_key(set_digit_format, -1), be_const_func(lvbe_spinbox_set_digit_format) },
{ be_const_key(increment, -1), be_const_func(lvbe_spinbox_increment) },
{ be_const_key(set_range, -1), be_const_func(lvbe_spinbox_set_range) },
{ be_const_key(get_rollover, -1), be_const_func(lvbe_spinbox_get_rollover) },
{ be_const_key(init, 2), be_const_func(lvbe_spinbox_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_step, -1), be_const_func(lvbe_spinbox_set_step) },
{ be_const_key(step_prev, 5), be_const_func(lvbe_spinbox_step_prev) },
{ be_const_key(create, -1), be_const_func(lvbe_spinbox_create) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_spinbox_map,
17
4
);
BE_EXPORT_VARIABLE be_define_const_class(

19
lib/libesp32/Berry/generate/be_fixed_be_class_lv_spinner.h
View File

@ -1,24 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_spinner_map) {
{ be_const_key(tostring, 8), be_const_func(lvx_tostring) },
{ be_const_key(get_dir, -1), be_const_func(lvbe_spinner_get_dir) },
{ be_const_key(get_arc_length, -1), be_const_func(lvbe_spinner_get_arc_length) },
{ be_const_key(dot_p, 4), be_const_int(0) },
{ be_const_key(create, -1), be_const_func(lvbe_spinner_create) },
{ be_const_key(get_spin_time, -1), be_const_func(lvbe_spinner_get_spin_time) },
{ be_const_key(init, 1), be_const_func(lvbe_spinner_create) },
{ be_const_key(anim_cb, -1), be_const_func(lvbe_spinner_anim_cb) },
{ be_const_key(set_spin_time, 10), be_const_func(lvbe_spinner_set_spin_time) },
{ be_const_key(set_arc_length, -1), be_const_func(lvbe_spinner_set_arc_length) },
{ be_const_key(set_type, 7), be_const_func(lvbe_spinner_set_type) },
{ be_const_key(get_type, 3), be_const_func(lvbe_spinner_get_type) },
{ be_const_key(set_dir, 5), be_const_func(lvbe_spinner_set_dir) },
{ be_const_key(init, 2), be_const_func(lvbe_spinner_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_spinner_map,
13
4
);
BE_EXPORT_VARIABLE be_define_const_class(

105
lib/libesp32/Berry/generate/be_fixed_be_class_lv_style.h
View File

@ -1,114 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_style_map) {
{ be_const_key(set_line_dash_width, -1), be_const_func(lvbe_style_set_line_dash_width) },
{ be_const_key(set_bg_grad_dir, -1), be_const_func(lvbe_style_set_bg_grad_dir) },
{ be_const_key(set_text_blend_mode, 84), be_const_func(lvbe_style_set_text_blend_mode) },
{ be_const_key(set_border_blend_mode, 75), be_const_func(lvbe_style_set_border_blend_mode) },
{ be_const_key(set_bg_main_stop, -1), be_const_func(lvbe_style_set_bg_main_stop) },
{ be_const_key(list_get_local_style, -1), be_const_func(lvbe_style_list_get_local_style) },
{ be_const_key(set_transform_height, 40), be_const_func(lvbe_style_set_transform_height) },
{ be_const_key(set_shadow_opa, 33), be_const_func(lvbe_style_set_shadow_opa) },
{ be_const_key(set_value_blend_mode, 51), be_const_func(lvbe_style_set_value_blend_mode) },
{ be_const_key(set_shadow_ofs_x, -1), be_const_func(lvbe_style_set_shadow_ofs_x) },
{ be_const_key(set_pattern_blend_mode, -1), be_const_func(lvbe_style_set_pattern_blend_mode) },
{ be_const_key(set_text_letter_space, -1), be_const_func(lvbe_style_set_text_letter_space) },
{ be_const_key(set_margin_right, 14), be_const_func(lvbe_style_set_margin_right) },
{ be_const_key(set_transition_delay, -1), be_const_func(lvbe_style_set_transition_delay) },
{ be_const_key(set_shadow_blend_mode, -1), be_const_func(lvbe_style_set_shadow_blend_mode) },
{ be_const_key(set_value_color, -1), be_const_func(lvbe_style_set_value_color) },
{ be_const_key(set_text_line_space, -1), be_const_func(lvbe_style_set_text_line_space) },
{ be_const_key(set_transition_prop_1, -1), be_const_func(lvbe_style_set_transition_prop_1) },
{ be_const_key(set_pattern_image, 47), be_const_func(lvbe_style_set_pattern_image) },
{ be_const_key(set_image_recolor, -1), be_const_func(lvbe_style_set_image_recolor) },
{ be_const_key(set_pattern_opa, -1), be_const_func(lvbe_style_set_pattern_opa) },
{ be_const_key(set_outline_blend_mode, -1), be_const_func(lvbe_style_set_outline_blend_mode) },
{ be_const_key(set_radius, -1), be_const_func(lvbe_style_set_radius) },
{ be_const_key(set_text_color, -1), be_const_func(lvbe_style_set_text_color) },
{ be_const_key(set_pattern_repeat, -1), be_const_func(lvbe_style_set_pattern_repeat) },
{ be_const_key(set_value_align, -1), be_const_func(lvbe_style_set_value_align) },
{ be_const_key(set_scale_width, 82), be_const_func(lvbe_style_set_scale_width) },
{ be_const_key(set_line_color, -1), be_const_func(lvbe_style_set_line_color) },
{ be_const_key(set_text_opa, 4), be_const_func(lvbe_style_set_text_opa) },
{ be_const_key(set_size, -1), be_const_func(lvbe_style_set_size) },
{ be_const_key(set_border_opa, 72), be_const_func(lvbe_style_set_border_opa) },
{ be_const_key(set_line_opa, 12), be_const_func(lvbe_style_set_line_opa) },
{ be_const_key(set_pad_inner, -1), be_const_func(lvbe_style_set_pad_inner) },
{ be_const_key(set_margin_bottom, -1), be_const_func(lvbe_style_set_margin_bottom) },
{ be_const_key(set_margin_top, 66), be_const_func(lvbe_style_set_margin_top) },
{ be_const_key(init, -1), be_const_func(lvs_init) },
{ be_const_key(set_transition_prop_2, -1), be_const_func(lvbe_style_set_transition_prop_2) },
{ be_const_key(set_transition_prop_5, -1), be_const_func(lvbe_style_set_transition_prop_5) },
{ be_const_key(set_transition_prop_6, 26), be_const_func(lvbe_style_set_transition_prop_6) },
{ be_const_key(set_border_post, 30), be_const_func(lvbe_style_set_border_post) },
{ be_const_key(set_scale_end_line_width, -1), be_const_func(lvbe_style_set_scale_end_line_width) },
{ be_const_key(set_pad_left, 64), be_const_func(lvbe_style_set_pad_left) },
{ be_const_key(set_scale_border_width, -1), be_const_func(lvbe_style_set_scale_border_width) },
{ be_const_key(set_line_blend_mode, 34), be_const_func(lvbe_style_set_line_blend_mode) },
{ be_const_key(set_image_recolor_opa, -1), be_const_func(lvbe_style_set_image_recolor_opa) },
{ be_const_key(set_bg_color, -1), be_const_func(lvbe_style_set_bg_color) },
{ be_const_key(set_pad_bottom, -1), be_const_func(lvbe_style_set_pad_bottom) },
{ be_const_key(set_transition_time, -1), be_const_func(lvbe_style_set_transition_time) },
{ be_const_key(set_outline_pad, 67), be_const_func(lvbe_style_set_outline_pad) },
{ be_const_key(set_transform_angle, 32), be_const_func(lvbe_style_set_transform_angle) },
{ be_const_key(set_value_line_space, -1), be_const_func(lvbe_style_set_value_line_space) },
{ be_const_key(set_image_opa, 76), be_const_func(lvbe_style_set_image_opa) },
{ be_const_key(set_pattern_recolor, -1), be_const_func(lvbe_style_set_pattern_recolor) },
{ be_const_key(set_bg_grad_color, 85), be_const_func(lvbe_style_set_bg_grad_color) },
{ be_const_key(set_value_letter_space, -1), be_const_func(lvbe_style_set_value_letter_space) },
{ be_const_key(set_shadow_spread, 0), be_const_func(lvbe_style_set_shadow_spread) },
{ be_const_key(set_text_font, 97), be_const_func(lvbe_style_set_text_font) },
{ be_const_key(set_line_width, -1), be_const_func(lvbe_style_set_line_width) },
{ be_const_key(set_shadow_color, -1), be_const_func(lvbe_style_set_shadow_color) },
{ be_const_key(set_transform_zoom, -1), be_const_func(lvbe_style_set_transform_zoom) },
{ be_const_key(set_outline_color, 79), be_const_func(lvbe_style_set_outline_color) },
{ be_const_key(set_shadow_ofs_y, 87), be_const_func(lvbe_style_set_shadow_ofs_y) },
{ be_const_key(set_text_sel_bg_color, -1), be_const_func(lvbe_style_set_text_sel_bg_color) },
{ be_const_key(set_text_decor, -1), be_const_func(lvbe_style_set_text_decor) },
{ be_const_key(init, 2), be_const_func(lvs_init) },
{ be_const_key(tostring, -1), be_const_func(lvs_tostring) },
{ be_const_key(set_clip_corner, -1), be_const_func(lvbe_style_set_clip_corner) },
{ be_const_key(set_value_str, -1), be_const_func(lvbe_style_set_value_str) },
{ be_const_key(set_pattern_recolor_opa, 16), be_const_func(lvbe_style_set_pattern_recolor_opa) },
{ be_const_key(set_border_side, -1), be_const_func(lvbe_style_set_border_side) },
{ be_const_key(set_scale_grad_color, -1), be_const_func(lvbe_style_set_scale_grad_color) },
{ be_const_key(set_line_rounded, 10), be_const_func(lvbe_style_set_line_rounded) },
{ be_const_key(set_pad_right, 35), be_const_func(lvbe_style_set_pad_right) },
{ be_const_key(set_transition_prop_4, -1), be_const_func(lvbe_style_set_transition_prop_4) },
{ be_const_key(set_transition_prop_3, 99), be_const_func(lvbe_style_set_transition_prop_3) },
{ be_const_key(list_init, -1), be_const_func(lvbe_style_list_init) },
{ be_const_key(set_transform_width, -1), be_const_func(lvbe_style_set_transform_width) },
{ be_const_key(set_bg_grad_stop, -1), be_const_func(lvbe_style_set_bg_grad_stop) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_value_opa, 50), be_const_func(lvbe_style_set_value_opa) },
{ be_const_key(set_value_font, -1), be_const_func(lvbe_style_set_value_font) },
{ be_const_key(set_text_sel_color, -1), be_const_func(lvbe_style_set_text_sel_color) },
{ be_const_key(set_outline_width, -1), be_const_func(lvbe_style_set_outline_width) },
{ be_const_key(set_value_ofs_x, 11), be_const_func(lvbe_style_set_value_ofs_x) },
{ be_const_key(set_scale_end_color, -1), be_const_func(lvbe_style_set_scale_end_color) },
{ be_const_key(set_margin_left, -1), be_const_func(lvbe_style_set_margin_left) },
{ be_const_key(copy, -1), be_const_func(lvbe_style_copy) },
{ be_const_key(set_shadow_width, -1), be_const_func(lvbe_style_set_shadow_width) },
{ be_const_key(set_bg_opa, -1), be_const_func(lvbe_style_set_bg_opa) },
{ be_const_key(list_copy, 73), be_const_func(lvbe_style_list_copy) },
{ be_const_key(set_value_ofs_y, 17), be_const_func(lvbe_style_set_value_ofs_y) },
{ be_const_key(set_opa_scale, 15), be_const_func(lvbe_style_set_opa_scale) },
{ be_const_key(set_scale_end_border_width, 37), be_const_func(lvbe_style_set_scale_end_border_width) },
{ be_const_key(set_border_color, 81), be_const_func(lvbe_style_set_border_color) },
{ be_const_key(set_line_dash_gap, 95), be_const_func(lvbe_style_set_line_dash_gap) },
{ be_const_key(set_bg_blend_mode, -1), be_const_func(lvbe_style_set_bg_blend_mode) },
{ be_const_key(remove_prop, 77), be_const_func(lvbe_style_remove_prop) },
{ be_const_key(set_border_width, -1), be_const_func(lvbe_style_set_border_width) },
{ be_const_key(set_image_blend_mode, -1), be_const_func(lvbe_style_set_image_blend_mode) },
{ be_const_key(set_transition_path, -1), be_const_func(lvbe_style_set_transition_path) },
{ be_const_key(set_outline_opa, 29), be_const_func(lvbe_style_set_outline_opa) },
{ be_const_key(reset, -1), be_const_func(lvbe_style_reset) },
{ be_const_key(set_pad_top, 45), be_const_func(lvbe_style_set_pad_top) },
{ be_const_key(list_get_style, -1), be_const_func(lvbe_style_list_get_style) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_style_map,
103
4
);
BE_EXPORT_VARIABLE be_define_const_class(

16
lib/libesp32/Berry/generate/be_fixed_be_class_lv_switch.h
View File

@ -1,21 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_switch_map) {
{ be_const_key(get_anim_time, 1), be_const_func(lvbe_switch_get_anim_time) },
{ be_const_key(init, -1), be_const_func(lvbe_switch_create) },
{ be_const_key(off, -1), be_const_func(lvbe_switch_off) },
{ be_const_key(toggle, -1), be_const_func(lvbe_switch_toggle) },
{ be_const_key(on, -1), be_const_func(lvbe_switch_on) },
{ be_const_key(tostring, 0), be_const_func(lvx_tostring) },
{ be_const_key(get_state, -1), be_const_func(lvbe_switch_get_state) },
{ be_const_key(set_anim_time, 8), be_const_func(lvbe_switch_set_anim_time) },
{ be_const_key(create, -1), be_const_func(lvbe_switch_create) },
{ be_const_key(dot_p, 6), be_const_int(0) },
{ be_const_key(init, 2), be_const_func(lvbe_switch_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_switch_map,
10
4
);
BE_EXPORT_VARIABLE be_define_const_class(

24
lib/libesp32/Berry/generate/be_fixed_be_class_lv_table.h
View File

@ -1,33 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_table_map) {
{ be_const_key(init, -1), be_const_func(lvbe_table_create) },
{ be_const_key(set_cell_crop, -1), be_const_func(lvbe_table_set_cell_crop) },
{ be_const_key(set_cell_value, -1), be_const_func(lvbe_table_set_cell_value) },
{ be_const_key(init, 2), be_const_func(lvbe_table_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_cell_merge_right, -1), be_const_func(lvbe_table_set_cell_merge_right) },
{ be_const_key(set_cell_type, -1), be_const_func(lvbe_table_set_cell_type) },
{ be_const_key(get_col_width, 15), be_const_func(lvbe_table_get_col_width) },
{ be_const_key(get_row_cnt, 12), be_const_func(lvbe_table_get_row_cnt) },
{ be_const_key(set_row_cnt, -1), be_const_func(lvbe_table_set_row_cnt) },
{ be_const_key(get_cell_crop, 0), be_const_func(lvbe_table_get_cell_crop) },
{ be_const_key(get_cell_align, 14), be_const_func(lvbe_table_get_cell_align) },
{ be_const_key(create, -1), be_const_func(lvbe_table_create) },
{ be_const_key(get_cell_merge_right, -1), be_const_func(lvbe_table_get_cell_merge_right) },
{ be_const_key(set_col_width, -1), be_const_func(lvbe_table_set_col_width) },
{ be_const_key(set_cell_align, -1), be_const_func(lvbe_table_set_cell_align) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_cell_value_fmt, 10), be_const_func(lvbe_table_set_cell_value_fmt) },
{ be_const_key(set_col_cnt, -1), be_const_func(lvbe_table_set_col_cnt) },
{ be_const_key(get_col_cnt, 17), be_const_func(lvbe_table_get_col_cnt) },
{ be_const_key(get_cell_type, 6), be_const_func(lvbe_table_get_cell_type) },
{ be_const_key(get_cell_value, 7), be_const_func(lvbe_table_get_cell_value) },
{ be_const_key(get_pressed_cell, 13), be_const_func(lvbe_table_get_pressed_cell) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_table_map,
22
4
);
BE_EXPORT_VARIABLE be_define_const_class(

19
lib/libesp32/Berry/generate/be_fixed_be_class_lv_tabview.h
View File

@ -1,26 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_tabview_map) {
{ be_const_key(init, -1), be_const_func(lvbe_tabview_create) },
{ be_const_key(get_anim_time, 13), be_const_func(lvbe_tabview_get_anim_time) },
{ be_const_key(set_anim_time, 8), be_const_func(lvbe_tabview_set_anim_time) },
{ be_const_key(add_tab, 6), be_const_func(lvbe_tabview_add_tab) },
{ be_const_key(init, 2), be_const_func(lvbe_tabview_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(set_btns_pos, 12), be_const_func(lvbe_tabview_set_btns_pos) },
{ be_const_key(get_tab_count, -1), be_const_func(lvbe_tabview_get_tab_count) },
{ be_const_key(get_tab_act, 11), be_const_func(lvbe_tabview_get_tab_act) },
{ be_const_key(create, -1), be_const_func(lvbe_tabview_create) },
{ be_const_key(get_btns_pos, -1), be_const_func(lvbe_tabview_get_btns_pos) },
{ be_const_key(set_tab_act, 1), be_const_func(lvbe_tabview_set_tab_act) },
{ be_const_key(clean_tab, -1), be_const_func(lvbe_tabview_clean_tab) },
{ be_const_key(get_tab, -1), be_const_func(lvbe_tabview_get_tab) },
{ be_const_key(tostring, 14), be_const_func(lvx_tostring) },
{ be_const_key(set_tab_name, -1), be_const_func(lvbe_tabview_set_tab_name) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_tabview_map,
15
4
);
BE_EXPORT_VARIABLE be_define_const_class(

51
lib/libesp32/Berry/generate/be_fixed_be_class_lv_textarea.h
View File

@ -1,58 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_textarea_map) {
{ be_const_key(get_text, -1), be_const_func(lvbe_textarea_get_text) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_pwd_mode, 10), be_const_func(lvbe_textarea_get_pwd_mode) },
{ be_const_key(get_text_sel_en, 27), be_const_func(lvbe_textarea_get_text_sel_en) },
{ be_const_key(set_scrollbar_mode, 41), be_const_func(lvbe_textarea_set_scrollbar_mode) },
{ be_const_key(set_cursor_click_pos, -1), be_const_func(lvbe_textarea_set_cursor_click_pos) },
{ be_const_key(set_text, 9), be_const_func(lvbe_textarea_set_text) },
{ be_const_key(del_char, 39), be_const_func(lvbe_textarea_del_char) },
{ be_const_key(cursor_right, 42), be_const_func(lvbe_textarea_cursor_right) },
{ be_const_key(cursor_up, -1), be_const_func(lvbe_textarea_cursor_up) },
{ be_const_key(cursor_down, -1), be_const_func(lvbe_textarea_cursor_down) },
{ be_const_key(set_text_align, 45), be_const_func(lvbe_textarea_set_text_align) },
{ be_const_key(set_pwd_mode, -1), be_const_func(lvbe_textarea_set_pwd_mode) },
{ be_const_key(del_char_forward, -1), be_const_func(lvbe_textarea_del_char_forward) },
{ be_const_key(text_is_selected, 38), be_const_func(lvbe_textarea_text_is_selected) },
{ be_const_key(get_cursor_hidden, -1), be_const_func(lvbe_textarea_get_cursor_hidden) },
{ be_const_key(set_text_sel, -1), be_const_func(lvbe_textarea_set_text_sel) },
{ be_const_key(set_insert_replace, -1), be_const_func(lvbe_textarea_set_insert_replace) },
{ be_const_key(get_max_length, 34), be_const_func(lvbe_textarea_get_max_length) },
{ be_const_key(set_cursor_blink_time, 25), be_const_func(lvbe_textarea_set_cursor_blink_time) },
{ be_const_key(add_char, 19), be_const_func(lvbe_textarea_add_char) },
{ be_const_key(init, -1), be_const_func(lvbe_textarea_create) },
{ be_const_key(get_edge_flash, -1), be_const_func(lvbe_textarea_get_edge_flash) },
{ be_const_key(set_cursor_hidden, 0), be_const_func(lvbe_textarea_set_cursor_hidden) },
{ be_const_key(get_one_line, -1), be_const_func(lvbe_textarea_get_one_line) },
{ be_const_key(get_placeholder_text, -1), be_const_func(lvbe_textarea_get_placeholder_text) },
{ be_const_key(set_cursor_pos, -1), be_const_func(lvbe_textarea_set_cursor_pos) },
{ be_const_key(get_scrollbar_mode, -1), be_const_func(lvbe_textarea_get_scrollbar_mode) },
{ be_const_key(get_cursor_blink_time, 17), be_const_func(lvbe_textarea_get_cursor_blink_time) },
{ be_const_key(get_scroll_propagation, 28), be_const_func(lvbe_textarea_get_scroll_propagation) },
{ be_const_key(get_label, 18), be_const_func(lvbe_textarea_get_label) },
{ be_const_key(cursor_left, -1), be_const_func(lvbe_textarea_cursor_left) },
{ be_const_key(set_accepted_chars, -1), be_const_func(lvbe_textarea_set_accepted_chars) },
{ be_const_key(set_placeholder_text, 31), be_const_func(lvbe_textarea_set_placeholder_text) },
{ be_const_key(set_max_length, -1), be_const_func(lvbe_textarea_set_max_length) },
{ be_const_key(get_accepted_chars, 37), be_const_func(lvbe_textarea_get_accepted_chars) },
{ be_const_key(get_cursor_click_pos, -1), be_const_func(lvbe_textarea_get_cursor_click_pos) },
{ be_const_key(get_cursor_pos, -1), be_const_func(lvbe_textarea_get_cursor_pos) },
{ be_const_key(set_pwd_show_time, -1), be_const_func(lvbe_textarea_set_pwd_show_time) },
{ be_const_key(set_edge_flash, -1), be_const_func(lvbe_textarea_set_edge_flash) },
{ be_const_key(clear_selection, 22), be_const_func(lvbe_textarea_clear_selection) },
{ be_const_key(get_pwd_show_time, -1), be_const_func(lvbe_textarea_get_pwd_show_time) },
{ be_const_key(init, 2), be_const_func(lvbe_textarea_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(set_one_line, -1), be_const_func(lvbe_textarea_set_one_line) },
{ be_const_key(add_text, 7), be_const_func(lvbe_textarea_add_text) },
{ be_const_key(set_scroll_propagation, -1), be_const_func(lvbe_textarea_set_scroll_propagation) },
{ be_const_key(create, -1), be_const_func(lvbe_textarea_create) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_textarea_map,
47
4
);
BE_EXPORT_VARIABLE be_define_const_class(

16
lib/libesp32/Berry/generate/be_fixed_be_class_lv_tileview.h
View File

@ -1,23 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_tileview_map) {
{ be_const_key(get_tile_act, 2), be_const_func(lvbe_tileview_get_tile_act) },
{ be_const_key(init, 2), be_const_func(lvbe_tileview_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(init, -1), be_const_func(lvbe_tileview_create) },
{ be_const_key(add_element, 0), be_const_func(lvbe_tileview_add_element) },
{ be_const_key(get_edge_flash, -1), be_const_func(lvbe_tileview_get_edge_flash) },
{ be_const_key(set_valid_positions, 6), be_const_func(lvbe_tileview_set_valid_positions) },
{ be_const_key(create, -1), be_const_func(lvbe_tileview_create) },
{ be_const_key(set_tile_act, 9), be_const_func(lvbe_tileview_set_tile_act) },
{ be_const_key(set_edge_flash, -1), be_const_func(lvbe_tileview_set_edge_flash) },
{ be_const_key(dot_p, 10), be_const_int(0) },
{ be_const_key(get_anim_time, -1), be_const_func(lvbe_tileview_get_anim_time) },
{ be_const_key(set_anim_time, -1), be_const_func(lvbe_tileview_set_anim_time) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_tileview_map,
12
4
);
BE_EXPORT_VARIABLE be_define_const_class(

35
lib/libesp32/Berry/generate/be_fixed_be_class_lv_win.h
View File

@ -1,42 +1,15 @@
#include "be_constobj.h"
static be_define_const_map_slots(be_class_lv_win_map) {
{ be_const_key(set_content_size, 10), be_const_func(lvbe_win_set_content_size) },
{ be_const_key(set_layout, -1), be_const_func(lvbe_win_set_layout) },
{ be_const_key(init, 2), be_const_func(lvbe_win_create) },
{ be_const_key(tostring, -1), be_const_func(lvx_tostring) },
{ be_const_key(dot_p, -1), be_const_int(0) },
{ be_const_key(get_title, -1), be_const_func(lvbe_win_get_title) },
{ be_const_key(clean, 8), be_const_func(lvbe_win_clean) },
{ be_const_key(get_content, -1), be_const_func(lvbe_win_get_content) },
{ be_const_key(set_btn_width, -1), be_const_func(lvbe_win_set_btn_width) },
{ be_const_key(title_get_alignment, -1), be_const_func(lvbe_win_title_get_alignment) },
{ be_const_key(scroll_hor, -1), be_const_func(lvbe_win_scroll_hor) },
{ be_const_key(add_btn_right, -1), be_const_func(lvbe_win_add_btn_right) },
{ be_const_key(get_anim_time, 13), be_const_func(lvbe_win_get_anim_time) },
{ be_const_key(init, -1), be_const_func(lvbe_win_create) },
{ be_const_key(get_from_btn, 15), be_const_func(lvbe_win_get_from_btn) },
{ be_const_key(add_btn_left, -1), be_const_func(lvbe_win_add_btn_left) },
{ be_const_key(title_set_alignment, -1), be_const_func(lvbe_win_title_set_alignment) },
{ be_const_key(scroll_ver, -1), be_const_func(lvbe_win_scroll_ver) },
{ be_const_key(set_header_height, -1), be_const_func(lvbe_win_set_header_height) },
{ be_const_key(focus, 19), be_const_func(lvbe_win_focus) },
{ be_const_key(set_anim_time, 5), be_const_func(lvbe_win_set_anim_time) },
{ be_const_key(close_event_cb, -1), be_const_func(lvbe_win_close_event_cb) },
{ be_const_key(create, -1), be_const_func(lvbe_win_create) },
{ be_const_key(get_sb_mode, 7), be_const_func(lvbe_win_get_sb_mode) },
{ be_const_key(get_btn_width, -1), be_const_func(lvbe_win_get_btn_width) },
{ be_const_key(get_width, -1), be_const_func(lvbe_win_get_width) },
{ be_const_key(get_layout, -1), be_const_func(lvbe_win_get_layout) },
{ be_const_key(set_drag, 2), be_const_func(lvbe_win_set_drag) },
{ be_const_key(tostring, 3), be_const_func(lvx_tostring) },
{ be_const_key(set_scrollbar_mode, -1), be_const_func(lvbe_win_set_scrollbar_mode) },
{ be_const_key(set_title, 24), be_const_func(lvbe_win_set_title) },
{ be_const_key(get_drag, 11), be_const_func(lvbe_win_get_drag) },
{ be_const_key(get_header_height, -1), be_const_func(lvbe_win_get_header_height) },
{ be_const_key(member, 0), be_const_func(lvx_member) },
};
static be_define_const_map(
be_class_lv_win_map,
31
4
);
BE_EXPORT_VARIABLE be_define_const_class(

526
lib/libesp32/Berry/generate/be_fixed_lvgl.h
View File

@ -1,474 +1,78 @@
#include "be_constobj.h"
static be_define_const_map_slots(m_liblvgl_map) {
{ be_const_key(screenshot, 63), be_const_func(lv0_screenshot) },
{ be_const_key(ALIGN_OUT_LEFT_BOTTOM, -1), be_const_int(17) },
{ be_const_key(SYMBOL_PLAY, 26), be_const_str(&be_local_const_str_SYMBOL_PLAY) },
{ be_const_key(DISP_SIZE_MEDIUM, -1), be_const_int(1) },
{ be_const_key(SYMBOL_BLUETOOTH, -1), be_const_str(&be_local_const_str_SYMBOL_BLUETOOTH) },
{ be_const_key(SLIDER_TYPE_RANGE, -1), be_const_int(2) },
{ be_const_key(LED_PART_MAIN, -1), be_const_int(0) },
{ be_const_key(SPINNER_DIR_BACKWARD, -1), be_const_int(1) },
{ be_const_key(STYLE_LINE_DASH_GAP, 10), be_const_int(147) },
{ be_const_key(STYLE_TRANSITION_PROP_2, -1), be_const_int(179) },
{ be_const_key(CHART_AXIS_SECONDARY_Y, -1), be_const_int(1) },
{ be_const_key(OPA_TRANSP, 79), be_const_int(0) },
{ be_const_key(OBJMASK_PART_MAIN, 32), be_const_int(0) },
{ be_const_key(DISP_SIZE_LARGE, 61), be_const_int(2) },
{ be_const_key(SYMBOL_SAVE, -1), be_const_str(&be_local_const_str_SYMBOL_SAVE) },
{ be_const_key(SLIDER_TYPE_SYMMETRICAL, 276), be_const_int(1) },
{ be_const_key(CHART_TYPE_LINE, -1), be_const_int(1) },
{ be_const_key(BLEND_MODE_ADDITIVE, -1), be_const_int(1) },
{ be_const_key(ALIGN_OUT_RIGHT_BOTTOM, -1), be_const_int(20) },
{ be_const_key(ALIGN_IN_BOTTOM_LEFT, -1), be_const_int(4) },
{ be_const_key(CHART_PART_SERIES, -1), be_const_int(2) },
{ be_const_key(LABEL_LONG_EXPAND, -1), be_const_int(0) },
{ be_const_key(STYLE_TEXT_LETTER_SPACE, 274), be_const_int(32896) },
{ be_const_key(SYMBOL_LIST, -1), be_const_str(&be_local_const_str_SYMBOL_LIST) },
{ be_const_key(STYLE_TRANSITION_PROP_6, -1), be_const_int(183) },
{ be_const_key(SYMBOL_HOME, -1), be_const_str(&be_local_const_str_SYMBOL_HOME) },
{ be_const_key(CHART_CURSOR_RIGHT, 157), be_const_int(1) },
{ be_const_key(OBJ_PART_REAL_FIRST, -1), be_const_int(64) },
{ be_const_key(STYLE_PAD_RIGHT, -1), be_const_int(19) },
{ be_const_key(EVENT_LONG_PRESSED, 134), be_const_int(4) },
{ be_const_key(TXT_FLAG_EXPAND, 66), be_const_int(2) },
{ be_const_key(BORDER_SIDE_RIGHT, 136), be_const_int(8) },
{ be_const_key(OBJ_PART_MAIN, -1), be_const_int(0) },
{ be_const_key(SYMBOL_NEW_LINE, -1), be_const_str(&be_local_const_str_SYMBOL_NEW_LINE) },
{ be_const_key(ANIM_OFF, -1), be_const_int(0) },
{ be_const_key(SYMBOL_OK, -1), be_const_str(&be_local_const_str_SYMBOL_OK) },
{ be_const_key(CALENDAR_PART_DAY_NAMES, 336), be_const_int(2) },
{ be_const_key(OPA_70, -1), be_const_int(178) },
{ be_const_key(OPA_60, 131), be_const_int(153) },
{ be_const_key(I2C, 339), be_const_int(1) },
{ be_const_key(PAGE_EDGE_LEFT, -1), be_const_int(1) },
{ be_const_key(OBJ_PART_ALL, -1), be_const_int(255) },
{ be_const_key(ALIGN_OUT_LEFT_TOP, 43), be_const_int(15) },
{ be_const_key(STYLE_LINE_DASH_WIDTH, -1), be_const_int(146) },
{ be_const_key(STYLE_SCALE_END_LINE_WIDTH, 17), be_const_int(195) },
{ be_const_key(LABEL_LONG_SROLL, -1), be_const_int(3) },
{ be_const_key(STYLE_SHADOW_COLOR, -1), be_const_int(89) },
{ be_const_key(BLEND_MODE_NORMAL, 442), be_const_int(0) },
{ be_const_key(layer_top, 234), be_const_func(lv0_layer_top) },
{ be_const_key(KEY_DEL, 206), be_const_int(127) },
{ be_const_key(FIT_MAX, -1), be_const_int(3) },
{ be_const_key(STYLE_CLIP_CORNER, 225), be_const_int(2) },
{ be_const_key(CHART_CURSOR_DOWN, 355), be_const_int(8) },
{ be_const_key(LAYOUT_COLUMN_LEFT, 448), be_const_int(2) },
{ be_const_key(LAYOUT_CENTER, 462), be_const_int(1) },
{ be_const_key(EVENT_APPLY, -1), be_const_int(19) },
{ be_const_key(STYLE_BORDER_COLOR, -1), be_const_int(57) },
{ be_const_key(SSPI, 406), be_const_int(2) },
{ be_const_key(STYLE_SCALE_BORDER_WIDTH, 146), be_const_int(193) },
{ be_const_key(SYMBOL_STOP, -1), be_const_str(&be_local_const_str_SYMBOL_STOP) },
{ be_const_key(FS_RES_NOT_IMP, -1), be_const_int(9) },
{ be_const_key(CPICKER_PART_MAIN, 143), be_const_int(0) },
{ be_const_key(KEY_NEXT, -1), be_const_int(9) },
{ be_const_key(SYMBOL_MINUS, 150), be_const_str(&be_local_const_str_SYMBOL_MINUS) },
{ be_const_key(ALIGN_OUT_TOP_RIGHT, -1), be_const_int(11) },
{ be_const_key(SYMBOL_EYE_CLOSE, -1), be_const_str(&be_local_const_str_SYMBOL_EYE_CLOSE) },
{ be_const_key(CHART_AXIS_PRIMARY_Y, 68), be_const_int(0) },
{ be_const_key(BTNMATRIX_CTRL_HIDDEN, -1), be_const_int(8) },
{ be_const_key(OPA_10, 116), be_const_int(25) },
{ be_const_key(SCROLLBAR_MODE_HIDE, -1), be_const_int(4) },
{ be_const_key(STYLE_BORDER_OPA, -1), be_const_int(60) },
{ be_const_key(SPINNER_TYPE_SPINNING_ARC, -1), be_const_int(0) },
{ be_const_key(BLEND_MODE_SUBTRACTIVE, 313), be_const_int(2) },
{ be_const_key(STYLE_TRANSFORM_ANGLE, -1), be_const_int(6) },
{ be_const_key(STYLE_TEXT_BLEND_MODE, -1), be_const_int(32899) },
{ be_const_key(STATE_PRESSED, 39), be_const_int(16) },
{ be_const_key(TXT_FLAG_FIT, -1), be_const_int(16) },
{ be_const_key(CPICKER_COLOR_MODE_SATURATION, 60), be_const_int(1) },
{ be_const_key(LIST_PART_EDGE_FLASH, -1), be_const_int(2) },
{ be_const_key(FS_RES_OUT_OF_MEM, 80), be_const_int(10) },
{ be_const_key(GRAD_DIR_VER, 120), be_const_int(1) },
{ be_const_key(BLACK, 435), be_const_int(0) },
{ be_const_key(KEY_UP, -1), be_const_int(17) },
{ be_const_key(STYLE_TRANSITION_PROP_4, -1), be_const_int(181) },
{ be_const_key(TXT_FLAG_RIGHT, 446), be_const_int(8) },
{ be_const_key(PAGE_EDGE_RIGHT, -1), be_const_int(4) },
{ be_const_key(ARC_PART_BG, 183), be_const_int(0) },
{ be_const_key(GESTURE_DIR_TOP, -1), be_const_int(0) },
{ be_const_key(TXT_CMD_STATE_WAIT, -1), be_const_int(0) },
{ be_const_key(DROPDOWN_DIR_UP, -1), be_const_int(1) },
{ be_const_key(STYLE_TEXT_SEL_COLOR, -1), be_const_int(32906) },
{ be_const_key(EVENT_DRAG_BEGIN, 109), be_const_int(8) },
{ be_const_key(FIT_NONE, -1), be_const_int(0) },
{ be_const_key(STYLE_PATTERN_RECOLOR_OPA, -1), be_const_int(109) },
{ be_const_key(BAR_TYPE_CUSTOM, -1), be_const_int(2) },
{ be_const_key(FS_RES_LOCKED, 137), be_const_int(5) },
{ be_const_key(SYMBOL_BATTERY_1, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_1) },
{ be_const_key(EVENT_CLICKED, 322), be_const_int(6) },
{ be_const_key(CPICKER_COLOR_MODE_VALUE, -1), be_const_int(2) },
{ be_const_key(TEXT_DECOR_NONE, -1), be_const_int(0) },
{ be_const_key(OPA_80, 112), be_const_int(204) },
{ be_const_key(KEY_DOWN, 414), be_const_int(18) },
{ be_const_key(EVENT_LEAVE, -1), be_const_int(15) },
{ be_const_key(STYLE_VALUE_OPA, -1), be_const_int(124) },
{ be_const_key(PROTECT_CLICK_FOCUS, -1), be_const_int(32) },
{ be_const_key(SYMBOL_EYE_OPEN, -1), be_const_str(&be_local_const_str_SYMBOL_EYE_OPEN) },
{ be_const_key(FS_RES_FULL, 337), be_const_int(4) },
{ be_const_key(STYLE_PATTERN_IMAGE, -1), be_const_int(110) },
{ be_const_key(EVENT_VALUE_CHANGED, 302), be_const_int(16) },
{ be_const_key(SYMBOL_FILE, -1), be_const_str(&be_local_const_str_SYMBOL_FILE) },
{ be_const_key(KEYBOARD_MODE_SPECIAL, 179), be_const_int(2) },
{ be_const_key(KEY_BACKSPACE, 99), be_const_int(8) },
{ be_const_key(OPA_90, -1), be_const_int(229) },
{ be_const_key(ARC_TYPE_NORMAL, -1), be_const_int(0) },
{ be_const_key(FS_MODE_RD, 196), be_const_int(2) },
{ be_const_key(ARC_PART_INDIC, -1), be_const_int(1) },
{ be_const_key(STYLE_VALUE_FONT, 441), be_const_int(126) },
{ be_const_key(GAUGE_PART_MAIN, -1), be_const_int(0) },
{ be_const_key(INDEV_STATE_REL, -1), be_const_int(0) },
{ be_const_key(STYLE_VALUE_ALIGN, 237), be_const_int(117) },
{ be_const_key(SYMBOL_EJECT, 424), be_const_str(&be_local_const_str_SYMBOL_EJECT) },
{ be_const_key(STYLE_TRANSITION_PROP_3, 328), be_const_int(180) },
{ be_const_key(BORDER_SIDE_FULL, -1), be_const_int(15) },
{ be_const_key(ALIGN_OUT_BOTTOM_LEFT, 182), be_const_int(12) },
{ be_const_key(SYMBOL_BACKSPACE, 176), be_const_str(&be_local_const_str_SYMBOL_BACKSPACE) },
{ be_const_key(SCROLLBAR_MODE_OFF, 126), be_const_int(0) },
{ be_const_key(HSPI, -1), be_const_int(0) },
{ be_const_key(DISP_SIZE_SMALL, -1), be_const_int(0) },
{ be_const_key(KEY_PREV, 236), be_const_int(11) },
{ be_const_key(SYMBOL_VOLUME_MID, 410), be_const_str(&be_local_const_str_SYMBOL_VOLUME_MID) },
{ be_const_key(PAGE_EDGE_TOP, 118), be_const_int(2) },
{ be_const_key(FS_MODE_WR, 270), be_const_int(1) },
{ be_const_key(YELLOW, -1), be_const_int(16776960) },
{ be_const_key(ARC_TYPE_SYMMETRIC, -1), be_const_int(1) },
{ be_const_key(CPICKER_PART_KNOB, -1), be_const_int(1) },
{ be_const_key(ALIGN_IN_RIGHT_MID, 443), be_const_int(8) },
{ be_const_key(CPICKER_TYPE_DISC, -1), be_const_int(1) },
{ be_const_key(KEY_ESC, -1), be_const_int(27) },
{ be_const_key(LABEL_ALIGN_RIGHT, -1), be_const_int(2) },
{ be_const_key(STYLE_LINE_BLEND_MODE, -1), be_const_int(145) },
{ be_const_key(CHART_CURSOR_NONE, 53), be_const_int(0) },
{ be_const_key(DROPDOWN_DIR_DOWN, -1), be_const_int(0) },
{ be_const_key(BTNMATRIX_CTRL_CLICK_TRIG, 350), be_const_int(256) },
{ be_const_key(OPA_100, -1), be_const_int(255) },
{ be_const_key(BTNMATRIX_CTRL_DISABLED, -1), be_const_int(32) },
{ be_const_key(scr_act, 38), be_const_func(lv0_scr_act) },
{ be_const_key(KEY_RIGHT, 403), be_const_int(19) },
{ be_const_key(BTN_STATE_PRESSED, 199), be_const_int(1) },
{ be_const_key(CPICKER_COLOR_MODE_HUE, -1), be_const_int(0) },
{ be_const_key(load_font, -1), be_const_func(lv0_load_font) },
{ be_const_key(DRAG_DIR_BOTH, -1), be_const_int(3) },
{ be_const_key(LIST_PART_SCROLLBAR, -1), be_const_int(1) },
{ be_const_key(CHART_AXIS_INVERSE_LABELS_ORDER, -1), be_const_int(2) },
{ be_const_key(FS_RES_UNKNOWN, 263), be_const_int(12) },
{ be_const_key(STYLE_BORDER_WIDTH, 226), be_const_int(48) },
{ be_const_key(MAROON, -1), be_const_int(8388608) },
{ be_const_key(LABEL_LONG_SROLL_CIRC, 155), be_const_int(4) },
{ be_const_key(ALIGN_OUT_BOTTOM_MID, 405), be_const_int(13) },
{ be_const_key(EVENT_INSERT, -1), be_const_int(17) },
{ be_const_key(STYLE_PAD_LEFT, -1), be_const_int(18) },
{ be_const_key(STYLE_SHADOW_OFS_Y, 344), be_const_int(82) },
{ be_const_key(ALIGN_IN_TOP_MID, -1), be_const_int(2) },
{ be_const_key(SYMBOL_WIFI, 5), be_const_str(&be_local_const_str_SYMBOL_WIFI) },
{ be_const_key(EVENT_DRAG_THROW_BEGIN, -1), be_const_int(10) },
{ be_const_key(SYMBOL_MUTE, 87), be_const_str(&be_local_const_str_SYMBOL_MUTE) },
{ be_const_key(TEMPL_STYLE_Y, 52), be_const_int(1) },
{ be_const_key(EVENT_PRESSING, -1), be_const_int(1) },
{ be_const_key(CHART_PART_CURSOR, -1), be_const_int(3) },
{ be_const_key(SYMBOL_VOLUME_MAX, -1), be_const_str(&be_local_const_str_SYMBOL_VOLUME_MAX) },
{ be_const_key(SYMBOL_BULLET, 315), be_const_str(&be_local_const_str_SYMBOL_BULLET) },
{ be_const_key(VSPI, -1), be_const_int(1) },
{ be_const_key(BTN_STATE_CHECKED_PRESSED, -1), be_const_int(4) },
{ be_const_key(ARC_TYPE_REVERSE, -1), be_const_int(2) },
{ be_const_key(CHART_PART_SERIES_BG, -1), be_const_int(1) },
{ be_const_key(PROTECT_PRESS_LOST, -1), be_const_int(16) },
{ be_const_key(FS_RES_HW_ERR, 333), be_const_int(1) },
{ be_const_key(STYLE_SHADOW_SPREAD, -1), be_const_int(83) },
{ be_const_key(PROTECT_CHILD_CHG, -1), be_const_int(1) },
{ be_const_key(STYLE_SCALE_GRAD_COLOR, -1), be_const_int(201) },
{ be_const_key(LABEL_ALIGN_CENTER, -1), be_const_int(1) },
{ be_const_key(LAYOUT_ROW_MID, 250), be_const_int(6) },
{ be_const_key(ALIGN_IN_TOP_RIGHT, 186), be_const_int(3) },
{ be_const_key(TXT_FLAG_CENTER, -1), be_const_int(4) },
{ be_const_key(SYMBOL_BATTERY_EMPTY, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_EMPTY) },
{ be_const_key(GAUGE_PART_MAJOR, 3), be_const_int(1) },
{ be_const_key(STYLE_LINE_WIDTH, -1), be_const_int(144) },
{ be_const_key(BORDER_SIDE_INTERNAL, 338), be_const_int(16) },
{ be_const_key(LAYOUT_ROW_BOTTOM, 224), be_const_int(7) },
{ be_const_key(BORDER_SIDE_TOP, -1), be_const_int(2) },
{ be_const_key(CHART_TYPE_NONE, 74), be_const_int(0) },
{ be_const_key(ALIGN_OUT_LEFT_MID, 221), be_const_int(16) },
{ be_const_key(DISP_ROT_270, 264), be_const_int(3) },
{ be_const_key(TXT_CMD_STATE_PAR, -1), be_const_int(1) },
{ be_const_key(SYMBOL_CLOSE, -1), be_const_str(&be_local_const_str_SYMBOL_CLOSE) },
{ be_const_key(STYLE_TEXT_FONT, -1), be_const_int(32910) },
{ be_const_key(TXT_FLAG_NONE, 372), be_const_int(0) },
{ be_const_key(EVENT_CANCEL, -1), be_const_int(20) },
{ be_const_key(FS_RES_DENIED, 233), be_const_int(6) },
{ be_const_key(STYLE_IMAGE_BLEND_MODE, 267), be_const_int(32928) },
{ be_const_key(STYLE_MARGIN_LEFT, 271), be_const_int(23) },
{ be_const_key(FS_RES_NOT_EX, -1), be_const_int(3) },
{ be_const_key(CHECKBOX_PART_BULLET, 266), be_const_int(64) },
{ be_const_key(PROTECT_FOLLOW, 89), be_const_int(8) },
{ be_const_key(WHITE, 54), be_const_int(16777215) },
{ be_const_key(DROPDOWN_PART_SELECTED, -1), be_const_int(66) },
{ be_const_key(PURPLE, -1), be_const_int(8388736) },
{ be_const_key(SILVER, 409), be_const_int(12632256) },
{ be_const_key(SYMBOL_KEYBOARD, -1), be_const_str(&be_local_const_str_SYMBOL_KEYBOARD) },
{ be_const_key(CHART_AXIS_SKIP_LAST_TICK, -1), be_const_int(0) },
{ be_const_key(LAYOUT_COLUMN_MID, -1), be_const_int(3) },
{ be_const_key(GRAD_DIR_HOR, 238), be_const_int(2) },
{ be_const_key(STYLE_MARGIN_BOTTOM, -1), be_const_int(22) },
{ be_const_key(SLIDER_TYPE_NORMAL, 400), be_const_int(0) },
{ be_const_key(STYLE_SCALE_END_COLOR, 173), be_const_int(202) },
{ be_const_key(STYLE_LINE_ROUNDED, 171), be_const_int(148) },
{ be_const_key(STYLE_VALUE_OFS_Y, -1), be_const_int(116) },
{ be_const_key(SYMBOL_NEXT, 107), be_const_str(&be_local_const_str_SYMBOL_NEXT) },
{ be_const_key(STATE_DEFAULT, 72), be_const_int(0) },
{ be_const_key(DRAG_DIR_HOR, -1), be_const_int(1) },
{ be_const_key(EVENT_GESTURE, 307), be_const_int(11) },
{ be_const_key(EVENT_PRESSED, -1), be_const_int(0) },
{ be_const_key(SPINNER_TYPE_FILLSPIN_ARC, -1), be_const_int(1) },
{ be_const_key(LABEL_LONG_BREAK, -1), be_const_int(1) },
{ be_const_key(FIT_TIGHT, -1), be_const_int(1) },
{ be_const_key(SYMBOL_RIGHT, 380), be_const_str(&be_local_const_str_SYMBOL_RIGHT) },
{ be_const_key(SYMBOL_COPY, 56), be_const_str(&be_local_const_str_SYMBOL_COPY) },
{ be_const_key(STYLE_BG_BLEND_MODE, -1), be_const_int(32) },
{ be_const_key(STYLE_BORDER_BLEND_MODE, -1), be_const_int(50) },
{ be_const_key(OPA_50, 354), be_const_int(127) },
{ be_const_key(BLUE, -1), be_const_int(255) },
{ be_const_key(SYMBOL_REFRESH, -1), be_const_str(&be_local_const_str_SYMBOL_REFRESH) },
{ be_const_key(ALIGN_OUT_TOP_MID, -1), be_const_int(10) },
{ be_const_key(ROLLER_MODE_INFINITE, -1), be_const_int(1) },
{ be_const_key(STATE_EDITED, -1), be_const_int(4) },
{ be_const_key(STATE_FOCUSED, -1), be_const_int(2) },
{ be_const_key(ANIM_ON, -1), be_const_int(1) },
{ be_const_key(EVENT_DEFOCUSED, -1), be_const_int(14) },
{ be_const_key(layer_sys, 321), be_const_func(lv0_layer_sys) },
{ be_const_key(SPINNER_DIR_FORWARD, 254), be_const_int(0) },
{ be_const_key(STYLE_SHADOW_OFS_X, -1), be_const_int(81) },
{ be_const_key(seg7_font, 434), be_const_func(lv0_load_seg7_font) },
{ be_const_key(LAYOUT_COLUMN_RIGHT, 369), be_const_int(4) },
{ be_const_key(ALIGN_IN_BOTTOM_MID, -1), be_const_int(5) },
{ be_const_key(DRAG_DIR_ONE, 341), be_const_int(4) },
{ be_const_key(KEY_ENTER, 294), be_const_int(10) },
{ be_const_key(GAUGE_PART_NEEDLE, 168), be_const_int(2) },
{ be_const_key(SYMBOL_DOWNLOAD, -1), be_const_str(&be_local_const_str_SYMBOL_DOWNLOAD) },
{ be_const_key(STATE_CHECKED, -1), be_const_int(1) },
{ be_const_key(STYLE_MARGIN_TOP, 83), be_const_int(21) },
{ be_const_key(STYLE_SHADOW_BLEND_MODE, 331), be_const_int(84) },
{ be_const_key(BAR_TYPE_SYMMETRICAL, -1), be_const_int(1) },
{ be_const_key(KEYBOARD_MODE_TEXT_UPPER, -1), be_const_int(1) },
{ be_const_key(ALIGN_OUT_BOTTOM_RIGHT, -1), be_const_int(14) },
{ be_const_key(CALENDAR_PART_BG, -1), be_const_int(0) },
{ be_const_key(LABEL_LONG_DOT, -1), be_const_int(2) },
{ be_const_key(CHART_PART_BG, -1), be_const_int(0) },
{ be_const_key(STATE_DISABLED, -1), be_const_int(32) },
{ be_const_key(FS_RES_TOUT, 280), be_const_int(8) },
{ be_const_key(OPA_COVER, 98), be_const_int(255) },
{ be_const_key(SYMBOL_DRIVE, -1), be_const_str(&be_local_const_str_SYMBOL_DRIVE) },
{ be_const_key(SYMBOL_IMAGE, 37), be_const_str(&be_local_const_str_SYMBOL_IMAGE) },
{ be_const_key(load_freetype_font, -1), be_const_func(lv0_load_freetype_font) },
{ be_const_key(STYLE_OUTLINE_OPA, 385), be_const_int(76) },
{ be_const_key(STYLE_OUTLINE_PAD, 365), be_const_int(65) },
{ be_const_key(BORDER_SIDE_LEFT, -1), be_const_int(4) },
{ be_const_key(STYLE_MARGIN_RIGHT, 62), be_const_int(24) },
{ be_const_key(STYLE_BG_COLOR, 402), be_const_int(41) },
{ be_const_key(BAR_TYPE_NORMAL, -1), be_const_int(0) },
{ be_const_key(STYLE_IMAGE_OPA, 286), be_const_int(32940) },
{ be_const_key(SCROLLBAR_MODE_ON, 211), be_const_int(1) },
{ be_const_key(KEY_END, 413), be_const_int(3) },
{ be_const_key(OPA_0, -1), be_const_int(0) },
{ be_const_key(CHECKBOX_PART_BG, -1), be_const_int(0) },
{ be_const_key(STYLE_TEXT_SEL_BG_COLOR, -1), be_const_int(32907) },
{ be_const_key(STYLE_OPA_SCALE, -1), be_const_int(32780) },
{ be_const_key(register_button_encoder, -1), be_const_func(lv0_register_button_encoder) },
{ be_const_key(SYMBOL_USB, -1), be_const_str(&be_local_const_str_SYMBOL_USB) },
{ be_const_key(TEMPL_STYLE_X, 153), be_const_int(0) },
{ be_const_key(TABVIEW_TAB_POS_BOTTOM, -1), be_const_int(2) },
{ be_const_key(CYAN, -1), be_const_int(65535) },
{ be_const_key(STYLE_OUTLINE_WIDTH, -1), be_const_int(64) },
{ be_const_key(STYLE_PAD_INNER, -1), be_const_int(20) },
{ be_const_key(STYLE_SIZE, -1), be_const_int(3) },
{ be_const_key(STYLE_VALUE_STR, -1), be_const_int(127) },
{ be_const_key(STYLE_PATTERN_BLEND_MODE, 318), be_const_int(96) },
{ be_const_key(EVENT_DELETE, 291), be_const_int(21) },
{ be_const_key(STYLE_VALUE_LINE_SPACE, -1), be_const_int(113) },
{ be_const_key(KEYBOARD_PART_BTN, 135), be_const_int(1) },
{ be_const_key(FS_RES_FS_ERR, -1), be_const_int(2) },
{ be_const_key(LAYOUT_GRID, -1), be_const_int(11) },
{ be_const_key(EVENT_SHORT_CLICKED, 281), be_const_int(3) },
{ be_const_key(LAYOUT_PRETTY_TOP, -1), be_const_int(8) },
{ be_const_key(KEY_HOME, 342), be_const_int(2) },
{ be_const_key(SYMBOL_DUMMY, -1), be_const_str(&be_local_const_str_SYMBOL_DUMMY) },
{ be_const_key(OBJ_PART_VIRTUAL_FIRST, -1), be_const_int(1) },
{ be_const_key(LABEL_LONG_CROP, -1), be_const_int(5) },
{ be_const_key(STATE_HOVERED, 122), be_const_int(8) },
{ be_const_key(STYLE_LINE_COLOR, 395), be_const_int(153) },
{ be_const_key(ALIGN_OUT_TOP_LEFT, -1), be_const_int(9) },
{ be_const_key(PROTECT_EVENT_TO_DISABLED, -1), be_const_int(64) },
{ be_const_key(SYMBOL_CHARGE, -1), be_const_str(&be_local_const_str_SYMBOL_CHARGE) },
{ be_const_key(INDEV_STATE_PR, -1), be_const_int(1) },
{ be_const_key(CHART_UPDATE_MODE_CIRCULAR, 88), be_const_int(1) },
{ be_const_key(SYMBOL_EDIT, -1), be_const_str(&be_local_const_str_SYMBOL_EDIT) },
{ be_const_key(ARC_PART_KNOB, -1), be_const_int(2) },
{ be_const_key(STYLE_TEXT_LINE_SPACE, -1), be_const_int(32897) },
{ be_const_key(STYLE_VALUE_LETTER_SPACE, -1), be_const_int(112) },
{ be_const_key(STYLE_SCALE_WIDTH, -1), be_const_int(192) },
{ be_const_key(AQUA, 253), be_const_int(65535) },
{ be_const_key(LAYOUT_PRETTY_MID, 19), be_const_int(9) },
{ be_const_key(DISP_ROT_90, -1), be_const_int(1) },
{ be_const_key(BTN_STATE_RELEASED, -1), be_const_int(0) },
{ be_const_key(DROPDOWN_PART_MAIN, -1), be_const_int(0) },
{ be_const_key(OPA_30, -1), be_const_int(76) },
{ be_const_key(SYMBOL_POWER, 431), be_const_str(&be_local_const_str_SYMBOL_POWER) },
{ be_const_key(GESTURE_DIR_RIGHT, -1), be_const_int(3) },
{ be_const_key(get_ver_res, 185), be_const_func(lv0_get_ver_res) },
{ be_const_key(SYMBOL_LOOP, -1), be_const_str(&be_local_const_str_SYMBOL_LOOP) },
{ be_const_key(DROPDOWN_DIR_LEFT, -1), be_const_int(2) },
{ be_const_key(LINEMETER_PART_MAIN, -1), be_const_int(0) },
{ be_const_key(STYLE_OUTLINE_COLOR, -1), be_const_int(73) },
{ be_const_key(SPINNER_TYPE_CONSTANT_ARC, -1), be_const_int(2) },
{ be_const_key(ROLLER_MODE_NORMAL, -1), be_const_int(0) },
{ be_const_key(SYMBOL_WARNING, 45), be_const_str(&be_local_const_str_SYMBOL_WARNING) },
{ be_const_key(STYLE_VALUE_BLEND_MODE, -1), be_const_int(114) },
{ be_const_key(KEYBOARD_MODE_NUM, -1), be_const_int(3) },
{ be_const_key(STYLE_BG_GRAD_STOP, -1), be_const_int(34) },
{ be_const_key(STYLE_VALUE_OFS_X, -1), be_const_int(115) },
{ be_const_key(SYMBOL_PLUS, -1), be_const_str(&be_local_const_str_SYMBOL_PLUS) },
{ be_const_key(CHART_AXIS_DRAW_LAST_TICK, -1), be_const_int(1) },
{ be_const_key(EVENT_FOCUSED, -1), be_const_int(13) },
{ be_const_key(STYLE_TRANSFORM_ZOOM, -1), be_const_int(7) },
{ be_const_key(TEXT_DECOR_STRIKETHROUGH, -1), be_const_int(2) },
{ be_const_key(LIST_PART_BG, -1), be_const_int(0) },
{ be_const_key(DROPDOWN_PART_LIST, 123), be_const_int(64) },
{ be_const_key(SYMBOL_BATTERY_3, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_3) },
{ be_const_key(STYLE_PAD_BOTTOM, -1), be_const_int(17) },
{ be_const_key(LAYOUT_PRETTY_BOTTOM, -1), be_const_int(10) },
{ be_const_key(GESTURE_DIR_LEFT, -1), be_const_int(2) },
{ be_const_key(STYLE_OUTLINE_BLEND_MODE, -1), be_const_int(66) },
{ be_const_key(STYLE_BG_MAIN_STOP, 100), be_const_int(33) },
{ be_const_key(PROTECT_POS, 246), be_const_int(4) },
{ be_const_key(PAGE_EDGE_BOTTOM, -1), be_const_int(8) },
{ be_const_key(CHART_UPDATE_MODE_SHIFT, 142), be_const_int(0) },
{ be_const_key(STYLE_TRANSITION_TIME, -1), be_const_int(176) },
{ be_const_key(STYLE_TRANSITION_PROP_1, -1), be_const_int(178) },
{ be_const_key(SYMBOL_UP, -1), be_const_str(&be_local_const_str_SYMBOL_UP) },
{ be_const_key(STYLE_PATTERN_OPA, -1), be_const_int(108) },
{ be_const_key(DRAG_DIR_VER, -1), be_const_int(2) },
{ be_const_key(PROTECT_PARENT, -1), be_const_int(2) },
{ be_const_key(STYLE_SHADOW_OPA, 352), be_const_int(92) },
{ be_const_key(STYLE_PATTERN_REPEAT, 160), be_const_int(97) },
{ be_const_key(SPI, 361), be_const_int(0) },
{ be_const_key(TEAL, -1), be_const_int(32896) },
{ be_const_key(EVENT_REFRESH, -1), be_const_int(18) },
{ be_const_key(DISP_SIZE_EXTRA_LARGE, -1), be_const_int(3) },
{ be_const_key(STYLE_BG_GRAD_DIR, -1), be_const_int(35) },
{ be_const_key(GRAD_DIR_NONE, -1), be_const_int(0) },
{ be_const_key(ALIGN_OUT_RIGHT_MID, -1), be_const_int(19) },
{ be_const_key(DROPDOWN_DIR_RIGHT, 417), be_const_int(3) },
{ be_const_key(STYLE_TRANSITION_PROP_5, -1), be_const_int(182) },
{ be_const_key(CHART_CURSOR_UP, -1), be_const_int(2) },
{ be_const_key(CHART_TYPE_COLUMN, -1), be_const_int(2) },
{ be_const_key(CPICKER_TYPE_RECT, -1), be_const_int(0) },
{ be_const_key(TABVIEW_TAB_POS_NONE, 23), be_const_int(0) },
{ be_const_key(STYLE_TEXT_OPA, -1), be_const_int(32908) },
{ be_const_key(OPA_20, 217), be_const_int(51) },
{ be_const_key(EVENT_KEY, -1), be_const_int(12) },
{ be_const_key(STYLE_SCALE_END_BORDER_WIDTH, -1), be_const_int(194) },
{ be_const_key(EVENT_PRESS_LOST, -1), be_const_int(2) },
{ be_const_key(BTN_STATE_CHECKED_RELEASED, 144), be_const_int(3) },
{ be_const_key(FS_RES_OK, 69), be_const_int(0) },
{ be_const_key(SYMBOL_BELL, -1), be_const_str(&be_local_const_str_SYMBOL_BELL) },
{ be_const_key(SYMBOL_BATTERY_FULL, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_FULL) },
{ be_const_key(ALIGN_IN_TOP_LEFT, 201), be_const_int(1) },
{ be_const_key(OPA_40, -1), be_const_int(102) },
{ be_const_key(BTNMATRIX_CTRL_NO_REPEAT, -1), be_const_int(16) },
{ be_const_key(STYLE_BORDER_SIDE, -1), be_const_int(49) },
{ be_const_key(LABEL_ALIGN_LEFT, -1), be_const_int(0) },
{ be_const_key(STYLE_IMAGE_RECOLOR, 408), be_const_int(32937) },
{ be_const_key(NAVY, -1), be_const_int(128) },
{ be_const_key(GREEN, -1), be_const_int(32768) },
{ be_const_key(SYMBOL_SHUFFLE, 212), be_const_str(&be_local_const_str_SYMBOL_SHUFFLE) },
{ be_const_key(GRAY, -1), be_const_int(8421504) },
{ be_const_key(STYLE_SHADOW_WIDTH, -1), be_const_int(80) },
{ be_const_key(SYMBOL_DIRECTORY, -1), be_const_str(&be_local_const_str_SYMBOL_DIRECTORY) },
{ be_const_key(BTNMATRIX_CTRL_CHECK_STATE, -1), be_const_int(128) },
{ be_const_key(TEXT_DECOR_UNDERLINE, 367), be_const_int(1) },
{ be_const_key(STYLE_BG_GRAD_COLOR, 141), be_const_int(42) },
{ be_const_key(SYMBOL_CALL, -1), be_const_str(&be_local_const_str_SYMBOL_CALL) },
{ be_const_key(STYLE_RADIUS, -1), be_const_int(1) },
{ be_const_key(CALENDAR_PART_HEADER, -1), be_const_int(1) },
{ be_const_key(start, 228), be_const_func(lv0_start) },
{ be_const_key(LAYOUT_ROW_TOP, -1), be_const_int(5) },
{ be_const_key(BTN_STATE_CHECKED_DISABLED, -1), be_const_int(5) },
{ be_const_key(SYMBOL_NEXT, -1), be_const_str(&be_local_const_str_SYMBOL_NEXT) },
{ be_const_key(SYMBOL_GPS, -1), be_const_str(&be_local_const_str_SYMBOL_GPS) },
{ be_const_key(get_hor_res, -1), be_const_func(lv0_get_hor_res) },
{ be_const_key(SYMBOL_AUDIO, -1), be_const_str(&be_local_const_str_SYMBOL_AUDIO) },
{ be_const_key(STYLE_BORDER_POST, 284), be_const_int(51) },
{ be_const_key(SYMBOL_SD_CARD, -1), be_const_str(&be_local_const_str_SYMBOL_SD_CARD) },
{ be_const_key(BORDER_SIDE_BOTTOM, 14), be_const_int(1) },
{ be_const_key(DROPDOWN_PART_SCROLLBAR, -1), be_const_int(65) },
{ be_const_key(SYMBOL_LEFT, -1), be_const_str(&be_local_const_str_SYMBOL_LEFT) },
{ be_const_key(KEY_LEFT, -1), be_const_int(20) },
{ be_const_key(LIME, -1), be_const_int(65280) },
{ be_const_key(SYMBOL_PASTE, -1), be_const_str(&be_local_const_str_SYMBOL_PASTE) },
{ be_const_key(SYMBOL_PAUSE, -1), be_const_str(&be_local_const_str_SYMBOL_PAUSE) },
{ be_const_key(FS_RES_INV_PARAM, -1), be_const_int(11) },
{ be_const_key(ALIGN_CENTER, -1), be_const_int(0) },
{ be_const_key(EVENT_RELEASED, -1), be_const_int(7) },
{ be_const_key(SYMBOL_PREV, -1), be_const_str(&be_local_const_str_SYMBOL_PREV) },
{ be_const_key(RED, -1), be_const_int(16711680) },
{ be_const_key(BORDER_SIDE_NONE, -1), be_const_int(0) },
{ be_const_key(ALIGN_IN_BOTTOM_RIGHT, -1), be_const_int(6) },
{ be_const_key(SYMBOL_TRASH, -1), be_const_str(&be_local_const_str_SYMBOL_TRASH) },
{ be_const_key(STYLE_PAD_TOP, -1), be_const_int(16) },
{ be_const_key(ALIGN_IN_LEFT_MID, 71), be_const_int(7) },
{ be_const_key(SYMBOL_CUT, 426), be_const_str(&be_local_const_str_SYMBOL_CUT) },
{ be_const_key(STYLE_IMAGE_RECOLOR_OPA, -1), be_const_int(32941) },
{ be_const_key(SCROLLBAR_MODE_AUTO, 148), be_const_int(3) },
{ be_const_key(STYLE_PATTERN_RECOLOR, 58), be_const_int(105) },
{ be_const_key(TABVIEW_TAB_POS_TOP, 438), be_const_int(1) },
{ be_const_key(BTN_STATE_DISABLED, -1), be_const_int(2) },
{ be_const_key(TEXTAREA_CURSOR_LAST, 285), be_const_int(32767) },
{ be_const_key(STYLE_TEXT_DECOR, 363), be_const_int(32898) },
{ be_const_key(FS_RES_BUSY, 399), be_const_int(7) },
{ be_const_key(KEYBOARD_MODE_TEXT_LOWER, -1), be_const_int(0) },
{ be_const_key(DISP_ROT_180, -1), be_const_int(2) },
{ be_const_key(OLIVE, -1), be_const_int(8421376) },
{ be_const_key(LAYOUT_OFF, -1), be_const_int(0) },
{ be_const_key(EVENT_DRAG_END, -1), be_const_int(9) },
{ be_const_key(EVENT_LONG_PRESSED_REPEAT, 432), be_const_int(5) },
{ be_const_key(SYMBOL_VIDEO, -1), be_const_str(&be_local_const_str_SYMBOL_VIDEO) },
{ be_const_key(SYMBOL_POWER, 29), be_const_str(&be_local_const_str_SYMBOL_POWER) },
{ be_const_key(SYMBOL_WARNING, -1), be_const_str(&be_local_const_str_SYMBOL_WARNING) },
{ be_const_key(SYMBOL_MUTE, 43), be_const_str(&be_local_const_str_SYMBOL_MUTE) },
{ be_const_key(SYMBOL_UP, -1), be_const_str(&be_local_const_str_SYMBOL_UP) },
{ be_const_key(SYMBOL_SHUFFLE, -1), be_const_str(&be_local_const_str_SYMBOL_SHUFFLE) },
{ be_const_key(SYMBOL_BATTERY_3, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_3) },
{ be_const_key(SYMBOL_VOLUME_MAX, -1), be_const_str(&be_local_const_str_SYMBOL_VOLUME_MAX) },
{ be_const_key(SYMBOL_PLUS, 31), be_const_str(&be_local_const_str_SYMBOL_PLUS) },
{ be_const_key(SYMBOL_SETTINGS, -1), be_const_str(&be_local_const_str_SYMBOL_SETTINGS) },
{ be_const_key(SYMBOL_PLAY, 58), be_const_str(&be_local_const_str_SYMBOL_PLAY) },
{ be_const_key(screenshot, 59), be_const_func(lv0_screenshot) },
{ be_const_key(SYMBOL_UPLOAD, -1), be_const_str(&be_local_const_str_SYMBOL_UPLOAD) },
{ be_const_key(KEYBOARD_PART_BG, -1), be_const_int(0) },
{ be_const_key(STYLE_TRANSITION_PATH, 113), be_const_int(190) },
{ be_const_key(STYLE_TRANSFORM_WIDTH, -1), be_const_int(4) },
{ be_const_key(STYLE_VALUE_COLOR, -1), be_const_int(121) },
{ be_const_key(ALIGN_OUT_RIGHT_TOP, -1), be_const_int(18) },
{ be_const_key(SYMBOL_DOWN, 167), be_const_str(&be_local_const_str_SYMBOL_DOWN) },
{ be_const_key(STYLE_TRANSITION_DELAY, -1), be_const_int(177) },
{ be_const_key(TABVIEW_TAB_POS_LEFT, -1), be_const_int(3) },
{ be_const_key(CALENDAR_PART_DATE, -1), be_const_int(3) },
{ be_const_key(TABVIEW_TAB_POS_RIGHT, 457), be_const_int(4) },
{ be_const_key(TXT_FLAG_RECOLOR, 353), be_const_int(1) },
{ be_const_key(FIT_PARENT, 180), be_const_int(2) },
{ be_const_key(LABEL_ALIGN_AUTO, -1), be_const_int(3) },
{ be_const_key(SYMBOL_LEFT, -1), be_const_str(&be_local_const_str_SYMBOL_LEFT) },
{ be_const_key(load_font, -1), be_const_func(lv0_load_font) },
{ be_const_key(SYMBOL_CALL, -1), be_const_str(&be_local_const_str_SYMBOL_CALL) },
{ be_const_key(SYMBOL_KEYBOARD, -1), be_const_str(&be_local_const_str_SYMBOL_KEYBOARD) },
{ be_const_key(SYMBOL_PAUSE, 40), be_const_str(&be_local_const_str_SYMBOL_PAUSE) },
{ be_const_key(SYMBOL_DOWN, -1), be_const_str(&be_local_const_str_SYMBOL_DOWN) },
{ be_const_key(SYMBOL_BATTERY_FULL, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_FULL) },
{ be_const_key(SYMBOL_BATTERY_EMPTY, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_EMPTY) },
{ be_const_key(SYMBOL_CLOSE, -1), be_const_str(&be_local_const_str_SYMBOL_CLOSE) },
{ be_const_key(SYMBOL_PASTE, 49), be_const_str(&be_local_const_str_SYMBOL_PASTE) },
{ be_const_key(SYMBOL_RIGHT, -1), be_const_str(&be_local_const_str_SYMBOL_RIGHT) },
{ be_const_key(SYMBOL_USB, 21), be_const_str(&be_local_const_str_SYMBOL_USB) },
{ be_const_key(SYMBOL_BULLET, -1), be_const_str(&be_local_const_str_SYMBOL_BULLET) },
{ be_const_key(SYMBOL_BELL, 7), be_const_str(&be_local_const_str_SYMBOL_BELL) },
{ be_const_key(SYMBOL_WIFI, -1), be_const_str(&be_local_const_str_SYMBOL_WIFI) },
{ be_const_key(SYMBOL_SAVE, -1), be_const_str(&be_local_const_str_SYMBOL_SAVE) },
{ be_const_key(SYMBOL_DOWNLOAD, -1), be_const_str(&be_local_const_str_SYMBOL_DOWNLOAD) },
{ be_const_key(start, -1), be_const_func(lv0_start) },
{ be_const_key(SYMBOL_DIRECTORY, 28), be_const_str(&be_local_const_str_SYMBOL_DIRECTORY) },
{ be_const_key(SYMBOL_TRASH, 35), be_const_str(&be_local_const_str_SYMBOL_TRASH) },
{ be_const_key(SYMBOL_IMAGE, -1), be_const_str(&be_local_const_str_SYMBOL_IMAGE) },
{ be_const_key(SYMBOL_VOLUME_MID, 54), be_const_str(&be_local_const_str_SYMBOL_VOLUME_MID) },
{ be_const_key(SYMBOL_STOP, 10), be_const_str(&be_local_const_str_SYMBOL_STOP) },
{ be_const_key(SYMBOL_DUMMY, -1), be_const_str(&be_local_const_str_SYMBOL_DUMMY) },
{ be_const_key(member, -1), be_const_func(lv0_member) },
{ be_const_key(SYMBOL_EDIT, -1), be_const_str(&be_local_const_str_SYMBOL_EDIT) },
{ be_const_key(seg7_font, 41), be_const_func(lv0_load_seg7_font) },
{ be_const_key(SYMBOL_NEW_LINE, -1), be_const_str(&be_local_const_str_SYMBOL_NEW_LINE) },
{ be_const_key(register_button_encoder, -1), be_const_func(lv0_register_button_encoder) },
{ be_const_key(load_freetype_font, -1), be_const_func(lv0_load_freetype_font) },
{ be_const_key(SYMBOL_REFRESH, 16), be_const_str(&be_local_const_str_SYMBOL_REFRESH) },
{ be_const_key(SYMBOL_SD_CARD, -1), be_const_str(&be_local_const_str_SYMBOL_SD_CARD) },
{ be_const_key(SYMBOL_EJECT, 20), be_const_str(&be_local_const_str_SYMBOL_EJECT) },
{ be_const_key(SYMBOL_CUT, 5), be_const_str(&be_local_const_str_SYMBOL_CUT) },
{ be_const_key(SYMBOL_LIST, 13), be_const_str(&be_local_const_str_SYMBOL_LIST) },
{ be_const_key(SYMBOL_MINUS, -1), be_const_str(&be_local_const_str_SYMBOL_MINUS) },
{ be_const_key(SYMBOL_LOOP, 8), be_const_str(&be_local_const_str_SYMBOL_LOOP) },
{ be_const_key(SYMBOL_EYE_CLOSE, 66), be_const_str(&be_local_const_str_SYMBOL_EYE_CLOSE) },
{ be_const_key(SYMBOL_BACKSPACE, -1), be_const_str(&be_local_const_str_SYMBOL_BACKSPACE) },
{ be_const_key(SYMBOL_OK, -1), be_const_str(&be_local_const_str_SYMBOL_OK) },
{ be_const_key(SYMBOL_AUDIO, -1), be_const_str(&be_local_const_str_SYMBOL_AUDIO) },
{ be_const_key(SYMBOL_EYE_OPEN, -1), be_const_str(&be_local_const_str_SYMBOL_EYE_OPEN) },
{ be_const_key(SYMBOL_BLUETOOTH, -1), be_const_str(&be_local_const_str_SYMBOL_BLUETOOTH) },
{ be_const_key(SYMBOL_VIDEO, -1), be_const_str(&be_local_const_str_SYMBOL_VIDEO) },
{ be_const_key(SYMBOL_HOME, -1), be_const_str(&be_local_const_str_SYMBOL_HOME) },
{ be_const_key(SYMBOL_BATTERY_2, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_2) },
{ be_const_key(TXT_CMD_STATE_IN, -1), be_const_int(2) },
{ be_const_key(STYLE_TEXT_COLOR, -1), be_const_int(32905) },
{ be_const_key(SCROLLBAR_MODE_DRAG, -1), be_const_int(2) },
{ be_const_key(MAGENTA, 377), be_const_int(16711935) },
{ be_const_key(DISP_ROT_NONE, 70), be_const_int(0) },
{ be_const_key(montserrat_font, 82), be_const_func(lv0_load_montserrat_font) },
{ be_const_key(STYLE_LINE_OPA, -1), be_const_int(156) },
{ be_const_key(BTNMATRIX_CTRL_CHECKABLE, -1), be_const_int(64) },
{ be_const_key(PROTECT_NONE, -1), be_const_int(0) },
{ be_const_key(SCROLLBAR_MODE_UNHIDE, -1), be_const_int(8) },
{ be_const_key(GESTURE_DIR_BOTTOM, 41), be_const_int(1) },
{ be_const_key(STYLE_TRANSFORM_HEIGHT, -1), be_const_int(5) },
{ be_const_key(STYLE_BG_OPA, -1), be_const_int(44) },
{ be_const_key(SYMBOL_SETTINGS, 379), be_const_str(&be_local_const_str_SYMBOL_SETTINGS) },
{ be_const_key(CHART_CURSOR_LEFT, -1), be_const_int(4) },
{ be_const_key(SYMBOL_COPY, -1), be_const_str(&be_local_const_str_SYMBOL_COPY) },
{ be_const_key(SYMBOL_DRIVE, -1), be_const_str(&be_local_const_str_SYMBOL_DRIVE) },
{ be_const_key(montserrat_font, 30), be_const_func(lv0_load_montserrat_font) },
{ be_const_key(SYMBOL_PREV, -1), be_const_str(&be_local_const_str_SYMBOL_PREV) },
{ be_const_key(SYMBOL_BATTERY_1, -1), be_const_str(&be_local_const_str_SYMBOL_BATTERY_1) },
{ be_const_key(SYMBOL_FILE, -1), be_const_str(&be_local_const_str_SYMBOL_FILE) },
{ be_const_key(SYMBOL_CHARGE, -1), be_const_str(&be_local_const_str_SYMBOL_CHARGE) },
};
static be_define_const_map(
m_liblvgl_map,
463
67
);
static be_define_const_module(

39
lib/libesp32/Berry/include/be_lvgl.h Normal file
View File

@ -0,0 +1,39 @@
/********************************************************************
* Tasmota LVGL Headers
*******************************************************************/
#ifndef __BE_LVGL_H__
#define __BE_LVGL_H__
#include "be_constobj.h"
#ifdef USE_LVGL
#include "lvgl.h"
#ifdef __cplusplus
extern "C" {
#endif
// table of functions per class
typedef struct lvbe_call_c_t {
const char * name;
void * func;
const char * return_type;
const char * arg_type;
} lvbe_call_c_t;
// list of classes and function tables
typedef struct lvbe_call_c_classes_t {
const char * name;
const lvbe_call_c_t * func_table;
size_t size;
} lvbe_call_c_classes_t;
extern const lvbe_call_c_classes_t lv_classes[];
extern const size_t lv_classes_size;
#ifdef __cplusplus
}
#endif
#endif // USE_LVGL
#endif // __BE_LVGL_H__

20
lib/libesp32/Berry/src/be_class.c
View File

@ -216,14 +216,30 @@ int be_instance_member(bvm *vm, binstance *obj, bstring *name, bvalue *dst)
return type;
}
bbool be_instance_setmember(bvm *vm, binstance *obj, bstring *name, bvalue *src)
bbool be_instance_setmember(bvm *vm, binstance *o, bstring *name, bvalue *src)
{
bvalue v;
be_assert(name != NULL);
obj = instance_member(vm, obj, name, &v);
binstance * obj = instance_member(vm, o, name, &v);
if (obj && var_istype(&v, MT_VARIABLE)) {
obj->members[var_toint(&v)] = *src;
return btrue;
} else {
obj = instance_member(vm, o, str_literal(vm, "setmember"), &v);
if (obj && var_type(&v) == MT_VARIABLE) {
v = obj->members[v.v.i];
}
if (var_basetype(&v) == BE_FUNCTION) {
bvalue *top = vm->top;
var_setval(top, &v);
var_setinstance(top + 1, o); /* move instance to argv[0] */
var_setstr(top + 2, name); /* move method name to argv[1] */
var_setval(top + 3, src); /* move method name to argv[1] */
vm->top += 4; /* prevent collection results */
be_dofunc(vm, top, 3); /* call method 'member' */
vm->top -= 4;
return var_tobool(top);
}
}
return bfalse;
}

68
lib/libesp32/Berry/src/be_vm.c
View File

@ -267,10 +267,26 @@ static void obj_method(bvm *vm, bvalue *o, bstring *attr, bvalue *dst)
}
}
static int obj_attribute(bvm *vm, bvalue *o, bstring *attr, bvalue *dst)
static int obj_attribute(bvm *vm, bvalue *o, bvalue *c, bvalue *dst)
{
bvalue instance = *o; /* save instance to send it later to member */
bstring *attr = var_tostr(c);
binstance *obj = var_toobj(o);
int type = be_instance_member(vm, obj, attr, dst);
if (basetype(type) == BE_NIL) { /* if no method found, try virtual */
/* get method 'member' */
int type2 = be_instance_member(vm, obj, str_literal(vm, "member"), vm->top);
if (basetype(type2) == BE_FUNCTION) {
bvalue *top = vm->top;
top[1] = instance; /* move instance to argv[0] */
top[2] = *c; /* move method name to argv[1] */
vm->top += 3; /* prevent collection results */
be_dofunc(vm, top, 2); /* call method 'member' */
vm->top -= 3;
*o = *vm->top; /* copy result to R(A) */
type = var_type(o);
}
}
if (basetype(type) == BE_NIL) {
vm_error(vm, "attribute_error",
"the '%s' object has no attribute '%s'",
@ -723,7 +739,8 @@ newframe: /* a new call frame */
opcase(GETMBR): {
bvalue *a = RA(), *b = RKB(), *c = RKC();
if (var_isinstance(b) && var_isstr(c)) {
obj_attribute(vm, b, var_tostr(c), a);
obj_attribute(vm, b, c, a);
reg = vm->reg;
} else if (var_ismodule(b) && var_isstr(c)) {
bstring *attr = var_tostr(c);
bmodule *module = var_toobj(b);
@ -731,9 +748,22 @@ newframe: /* a new call frame */
if (v) {
*a = *v;
} else {
vm_error(vm, "attribute_error",
"module '%s' has no attribute '%s'",
be_module_name(module), str(attr));
bvalue *member = be_module_attr(vm, module, str_literal(vm, "member"));
var_setnil(a);
if (member && var_basetype(member) == BE_FUNCTION) {
bvalue *top = vm->top;
top[0] = *member;
top[1] = *c; /* move name to argv[0] */
vm->top += 2; /* prevent collection results */
be_dofunc(vm, top, 1); /* call method 'method' */
vm->top -= 2;
*a = *vm->top; /* copy result to R(A) */
}
if (var_basetype(a) == BE_NIL) {
vm_error(vm, "attribute_error",
"module '%s' has no attribute '%s'",
be_module_name(module), str(attr));
}
}
} else {
attribute_error(vm, "attribute", b, c);
@ -746,12 +776,10 @@ newframe: /* a new call frame */
bvalue self = *b;
bstring *attr = var_tostr(c);
binstance *obj = var_toobj(b);
int type = obj_attribute(vm, b, var_tostr(c), a);
if (type == MT_METHOD || type == MT_PRIMMETHOD) {
int type = obj_attribute(vm, b, c, a);
reg = vm->reg;
if (basetype(type) == BE_FUNCTION) {
a[1] = self;
} else if (var_basetype(a) == BE_FUNCTION) {
a[1] = *a;
var_settype(a, NOT_METHOD);
} else {
vm_error(vm, "attribute_error",
"class '%s' has no method '%s'",
@ -765,9 +793,23 @@ newframe: /* a new call frame */
var_settype(a, NOT_METHOD);
a[1] = *src;
} else {
vm_error(vm, "attribute_error",
"module '%s' has no method '%s'",
be_module_name(module), str(attr));
bvalue *member = be_module_attr(vm, module, str_literal(vm, "member"));
var_setnil(a);
if (member && var_basetype(member) == BE_FUNCTION) {
bvalue *top = vm->top;
top[0] = *member;
top[1] = *c; /* move name to argv[0] */
vm->top += 2; /* prevent collection results */
be_dofunc(vm, top, 1); /* call method 'method' */
vm->top -= 2;
var_settype(a, NOT_METHOD);
a[1] = *vm->top; /* copy result to R(A) */
}
if (var_basetype(a) == BE_NIL) {
vm_error(vm, "attribute_error",
"module '%s' has no method '%s'",
be_module_name(module), str(attr));
}
}
} else {
attribute_error(vm, "method", b, c);

66
lib/libesp32/Berry/tests/virtual_methods.be Normal file
View File

@ -0,0 +1,66 @@
#- basic initialization -#
def assert_attribute_error(f)
try
f()
assert(false, 'unexpected execution flow')
except .. as e, m
assert(e == 'attribute_error')
end
end
class T1
var a, b
def init()
self.a = 1
self.b = 2
end
def f() return true end
def g() return false end
end
t = T1()
#- warm up -#
assert(t.a == 1)
assert(t.b == 2)
assert(t.f() == true)
assert(t.g() == false)
#- test normal errors when method does not exist -#
assert_attribute_error(/-> t.h())
assert_attribute_error(/-> t.c)
class T2 : T1
def member(n)
if (n == 'f1') return / n -> n end
if (n == 'f2') return /-> 4 end
if (n == 'a1') return 10 end
end
end
t2 = T2()
#- test non-regression -#
assert(t2.a == 1)
assert(t2.b == 2)
assert(t2.f() == true)
assert(t2.g() == false)
assert_attribute_error(/-> t2.h())
#- try virtual methods -#
assert(t2.f1() == t2)
assert(t2.f2() == 4)
assert(t2.a1 == 10)
#- module -#
m = module("m")
m.a = 1
assert(m.a == 1)
assert_attribute_error(/-> m.b)
m.member = def(n)
if n == "b" return 2 end
end
assert(m.b == 2)
assert_attribute_error(/-> m.c)

4
lib/libesp32_lvgl/LVGL/src/lv_misc/lv_fs.c
View File

@ -148,7 +148,9 @@ lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
lv_fs_res_t res = file_p->drv->close_cb(file_p->drv, file_p->file_d);
lv_mem_free(file_p->file_d); /*Clean up*/
if(file_p->drv->file_size != 0) { /*Is file_d zero size?*/
lv_mem_free(file_p->file_d); /*Clean up*/
}
file_p->file_d = NULL;
file_p->drv = NULL;

50
lib/libesp32_lvgl/lv_lib_png/README.md Normal file
View File

@ -0,0 +1,50 @@
# PNG decoder for LVGL
Allow the use of PNG images in LVGL. This implementation uses [lodepng](https://github.com/lvandeve/lodepng) library.
## Get started
- Download or clone this repository
- [Download from GitHub](https://github.com/littlevgl/lv_lib_lodepng/archive/master.zip)
- Clone: `git clone https://github.com/littlevgl/lv_lib_png.git`
- Include the library: `#include "lv_lib_png/lv_png.h"`
- Initalize the decocer with `lv_png_init()`
- Test with the following code:
```c
LV_IMG_DECLARE(png_decoder_test);
lv_obj_t * img = lv_img_create(lv_scr_act(), NULL);
lv_img_set_src(img, &png_decoder_test);
```
## Use PNG images from file
By deafult `lodepng` uses C file IO API (e.g. `fopen`) and images can be opened like this:
```c
lv_img_set_src(img, "./lv_lib_lodepng/png_decoder_test.png");
```
If you want to make `lodepng` to use LVGL's file system API add `#define LV_PNG_USE_LV_FILESYSTEM 1` to the end of your`lv_conf.h`.
In this case you need to [register a driver](https://docs.lvgl.io/latest/en/html/overview/file-system.html) fo LVGL. The following functions are required:
- `open_cb()`
- `read_cb()`
- `close_cb()`
- `size_cb()`
After that fiels can be opened like this:
```c
lv_img_set_src(img, "P:lv_lib_lodepng/png_decoder_test.png");
```
Note that the path of the file might be different.
## Use PNG images from flash
To store a PNG image in flash it needs to be converted to C array with [Online Image converter](https://lvgl.io/tools/imageconverter). Choose `Raw with alpha` Color format and `C array` Output format. Copy the result C array to your project and use it like this:
```c
LV_IMG_DECLARE(my_test_img);
lv_obj_t * img = lv_img_create(lv_scr_act(), NULL);
lv_img_set_src(img, &my_test_img);
```
## Learn more
To learn more about the PNG decoder itself read [this blog post](https://blog.littlevgl.com/2018-10-05/png_converter)
To learn more about the Image decoder interface of LittlevGL read the realevant part of the [documentation](https://docs.littlevgl.com/en/html/overview/image.html#image-decoder).

21
lib/libesp32_lvgl/lv_lib_png/library.json Normal file
View File

@ -0,0 +1,21 @@
{
"name":"lv_lib_png",
"description":"Allow the use of PNG images in LVGL. This implementation uses lodepng library.",
"keywords":"lvgl, png",
"license": "MIT License",
"repository": {
"type": "git",
"url": "https://github.com/lvgl/lv_lib_png"
},
"frameworks": "arduino",
"platforms": "espressif32",
"build": {
"flags": [ "-DLV_PNG_USE_LV_FILESYSTEM=1",
"-DLODEPNG_NO_COMPILE_ALLOCATORS",
"-DLODEPNG_NO_COMPILE_ERROR_TEXT",
"-DLODEPNG_NO_COMPILE_ANCILLARY_CHUNKS",
"-DLV_LVGL_H_INCLUDE_SIMPLE",
"-I$PROJECT_DIR/include",
"-includetasmota_options.h" ]
}
}

6487
lib/libesp32_lvgl/lv_lib_png/src/lodepng.c Normal file
View File

File diff suppressed because it is too large Load Diff

1989
lib/libesp32_lvgl/lv_lib_png/src/lodepng.h Normal file
View File

File diff suppressed because it is too large Load Diff

267
lib/libesp32_lvgl/lv_lib_png/src/lv_png.c Normal file
View File

@ -0,0 +1,267 @@
/**
* @file lv_png.c
*
*/
/*********************
* INCLUDES
*********************/
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include <lvgl.h>
#else
#include <lvgl/lvgl.h>
#endif
#include "lv_png.h"
#include "lodepng.h"
#include <stdlib.h>
#if LV_MEM_CUSTOM != 0
#include LV_MEM_CUSTOM_INCLUDE
#endif
#include <stdio.h>
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static lv_res_t decoder_info(struct _lv_img_decoder * decoder, const void * src, lv_img_header_t * header);
static lv_res_t decoder_open(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
static void decoder_close(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
static void convert_color_depth(uint8_t * img, uint32_t px_cnt);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Register the PNG decoder functions in LittlevGL
*/
void lv_png_init(void)
{
lv_img_decoder_t * dec = lv_img_decoder_create();
lv_img_decoder_set_info_cb(dec, decoder_info);
lv_img_decoder_set_open_cb(dec, decoder_open);
lv_img_decoder_set_close_cb(dec, decoder_close);
}
/**********************
* STATIC FUNCTIONS
**********************/
/**
* Get info about a PNG image
* @param src can be file name or pointer to a C array
* @param header store the info here
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info
*/
static lv_res_t decoder_info(struct _lv_img_decoder * decoder, const void * src, lv_img_header_t * header)
{
(void) decoder; /*Unused*/
lv_img_src_t src_type = lv_img_src_get_type(src); /*Get the source type*/
/*If it's a PNG file...*/
if(src_type == LV_IMG_SRC_FILE) {
const char * fn = src;
if(!strcmp(&fn[strlen(fn) - 3], "png")) { /*Check the extension*/
/* Read the width and height from the file. They have a constant location:
* [16..23]: width
* [24..27]: height
*/
uint32_t size[2];
#if LV_PNG_USE_LV_FILESYSTEM
lv_fs_file_t f;
lv_fs_res_t res = lv_fs_open(&f, fn, LV_FS_MODE_RD);
if(res != LV_FS_RES_OK) return -1;
lv_fs_seek(&f, 16);
uint32_t rn;
lv_fs_read(&f, &size, 8, &rn);
if(rn != 8) return LV_RES_INV;
lv_fs_close(&f);
#else
FILE* file;
file = fopen(fn, "rb" );
if(!file) return LV_RES_INV;
fseek(file, 16, SEEK_SET);
size_t rn = fread(size, 1 , 8, file);
fclose(file);
if(rn != 8) return LV_RES_INV;
#endif
/*Save the data in the header*/
header->always_zero = 0;
header->cf = LV_IMG_CF_RAW_ALPHA;
/*The width and height are stored in Big endian format so convert them to little endian*/
header->w = (lv_coord_t) ((size[0] & 0xff000000) >> 24) + ((size[0] & 0x00ff0000) >> 8);
header->h = (lv_coord_t) ((size[1] & 0xff000000) >> 24) + ((size[1] & 0x00ff0000) >> 8);
return LV_RES_OK;
}
}
/*If it's a PNG file in a C array...*/
else if(src_type == LV_IMG_SRC_VARIABLE) {
const lv_img_dsc_t * img_dsc = src;
header->always_zero = 0;
header->cf = img_dsc->header.cf; /*Save the color format*/
header->w = img_dsc->header.w; /*Save the color width*/
header->h = img_dsc->header.h; /*Save the color height*/
return LV_RES_OK;
}
return LV_RES_INV; /*If didn't succeeded earlier then it's an error*/
}
/**
* Open a PNG image and return the decided image
* @param src can be file name or pointer to a C array
* @param style style of the image object (unused now but certain formats might use it)
* @return pointer to the decoded image or `LV_IMG_DECODER_OPEN_FAIL` if failed
*/
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
{
(void) decoder; /*Unused*/
uint32_t error; /*For the return values of PNG decoder functions*/
uint8_t * img_data = NULL;
/*If it's a PNG file...*/
if(dsc->src_type == LV_IMG_SRC_FILE) {
const char * fn = dsc->src;
if(!strcmp(&fn[strlen(fn) - 3], "png")) { /*Check the extension*/
/*Load the PNG file into buffer. It's still compressed (not decoded)*/
unsigned char * png_data; /*Pointer to the loaded data. Same as the original file just loaded into the RAM*/
size_t png_data_size; /*Size of `png_data` in bytes*/
error = lodepng_load_file(&png_data, &png_data_size, fn); /*Load the file*/
if(error) {
#ifdef LODEPNG_COMPILE_ERROR_TEXT
LV_LOG_ERROR("lv_png error %u: %s\n", error, lodepng_error_text(error));
#else
LV_LOG_ERROR("lv_png error %u\n", error);
#endif
return LV_RES_INV;
}
/*Decode the PNG image*/
uint32_t png_width; /*Will be the width of the decoded image*/
uint32_t png_height; /*Will be the width of the decoded image*/
/*Decode the loaded image in ARGB8888 */
error = lodepng_decode32(&img_data, &png_width, &png_height, png_data, png_data_size);
LV_MEM_CUSTOM_FREE(png_data); /*Free the loaded file*/
if(error) {
#ifdef LODEPNG_COMPILE_ERROR_TEXT
LV_LOG_ERROR("lv_png error %u: %s\n", error, lodepng_error_text(error));
#else
LV_LOG_ERROR("lv_png error %u\n", error);
#endif
return LV_RES_INV;
}
/*Convert the image to the system's color depth*/
convert_color_depth(img_data, png_width * png_height);
dsc->img_data = img_data;
return LV_RES_OK; /*The image is fully decoded. Return with its pointer*/
}
}
/*If it's a PNG file in a C array...*/
else if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
const lv_img_dsc_t * img_dsc = dsc->src;
uint32_t png_width; /*No used, just required by he decoder*/
uint32_t png_height; /*No used, just required by he decoder*/
/*Decode the image in ARGB8888 */
error = lodepng_decode32(&img_data, &png_width, &png_height, img_dsc->data, img_dsc->data_size);
if(error) {
return LV_RES_INV;
}
/*Convert the image to the system's color depth*/
convert_color_depth(img_data, png_width * png_height);
dsc->img_data = img_data;
return LV_RES_OK; /*Return with its pointer*/
}
return LV_RES_INV; /*If not returned earlier then it failed*/
}
/**
* Free the allocated resources
*/
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
{
(void) decoder; /*Unused*/
if(dsc->img_data) LV_MEM_CUSTOM_FREE((uint8_t *)dsc->img_data);
}
/**
* If the display is not in 32 bit format (ARGB888) then covert the image to the current color depth
* @param img the ARGB888 image
* @param px_cnt number of pixels in `img`
*/
static void convert_color_depth(uint8_t * img, uint32_t px_cnt)
{
#if LV_COLOR_DEPTH == 32
lv_color32_t * img_argb = (lv_color32_t*)img;
lv_color_t c;
lv_color_t * img_c = (lv_color_t *) img;
uint32_t i;
for(i = 0; i < px_cnt; i++) {
c = LV_COLOR_MAKE(img_argb[i].ch.red, img_argb[i].ch.green, img_argb[i].ch.blue);
img_c[i].ch.red = c.ch.blue;
img_c[i].ch.blue = c.ch.red;
}
#elif LV_COLOR_DEPTH == 16
lv_color32_t * img_argb = (lv_color32_t*)img;
lv_color_t c;
uint32_t i;
for(i = 0; i < px_cnt; i++) {
c = LV_COLOR_MAKE(img_argb[i].ch.blue, img_argb[i].ch.green, img_argb[i].ch.red);
img[i*3 + 2] = img_argb[i].ch.alpha;
img[i*3 + 1] = c.full >> 8;
img[i*3 + 0] = c.full & 0xFF;
}
#ifdef LV_MEM_CUSTOM_REALLOC
LV_MEM_CUSTOM_REALLOC(img, px_cnt * 3); /*Shrink the buffer*/
#else
realloc(img, px_cnt * 3); /*Shrink the buffer*/
#endif
#elif LV_COLOR_DEPTH == 8
lv_color32_t * img_argb = (lv_color32_t*)img;
lv_color_t c;
uint32_t i;
for(i = 0; i < px_cnt; i++) {
c = LV_COLOR_MAKE(img_argb[i].red, img_argb[i].green, img_argb[i].blue);
img[i*3 + 1] = img_argb[i].alpha;
img[i*3 + 0] = c.full
}
#if LV_MEM_CUSTOM_REALLOC
LV_MEM_CUSTOM_REALLOC(img, px_cnt * 2); /*Shrink the buffer*/
#else
realloc(img, px_cnt * 2); /*Shrink the buffer*/
#endif
#endif
}

43
lib/libesp32_lvgl/lv_lib_png/src/lv_png.h Normal file
View File

@ -0,0 +1,43 @@
/**
* @file lv_png.h
*
*/
#ifndef LV_PNG_H
#define LV_PNG_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/**
* Register the PNG decoder functions in LittlevGL
*/
void lv_png_init(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*LV_PNG_H*/

61
tasmota/berry/watch_renaissance/autoexec.be Normal file
View File

@ -0,0 +1,61 @@
#-
- Example of Smart Watch on a 240x240 screen.
-
- Assets are borrowed from https://www.facer.io/watchface/HC77XaKNNM?watchModel=waldhoffrenaissance
- and simulates The Waldhoff Renaissance
-
- Copy all assets in the file-system, including this file
-#
lv.start()
scr = lv.scr_act()
scr.set_style_local_bg_color(lv.OBJ_PART_MAIN, lv.STATE_DEFAULT, lv_color(lv.BLACK))
ren_back = lv_img(scr)
ren_back.set_src("A:/watch_ren_back_240.png")
ren_back.align(0, lv.ALIGN_CENTER, 0, 0)
ren_day = lv_label(ren_back)
ren_day.set_style_local_text_color(lv.OBJ_PART_MAIN, lv.STATE_DEFAULT, lv_color(lv.BLACK))
ren_day.set_long_mode(lv.LABEL_LONG_CROP)
ren_day.set_align(lv.LABEL_ALIGN_CENTER)
ren_day.set_text("")
ren_day.set_width(18)
ren_day.set_height(16)
ren_day.set_pos(184,112)
ren_hour = lv_img(ren_back)
ren_hour.set_src("A:/watch_ren_hour_240.png")
ren_hour.set_pos(110,45)
ren_min = lv_img(ren_back)
ren_min.set_src("A:/watch_ren_min_240.png")
ren_sec = lv_img(ren_back)
ren_sec.set_src("A:/watch_ren_sec_240.png")
ren_sec.set_pos(110,10)
prev_day = -1
def set_watch()
now = tasmota.rtc()
time_raw = now['local'] + now['timezone'] * 60
time = tasmota.time_dump(time_raw)
# set second
ren_sec.set_angle(60 * time['sec'])
# set minutes
ren_min.set_angle(60 * time['min'])
# set hours
ren_hour.set_angle(300 * (time['hour'] % 12) + time['min'] * 5)
# set day
if time['day'] != prev_day
ren_day.set_text(str(time['day']))
prev_day = time['day']
end
end
def run_watch()
set_watch()
tasmota.set_timer(100, run_watch)
end
run_watch()

BIN
tasmota/berry/watch_renaissance/watch_ren_back_240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 95 KiB

BIN
tasmota/berry/watch_renaissance/watch_ren_hour_240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.0 KiB

BIN
tasmota/berry/watch_renaissance/watch_ren_min_240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.3 KiB

BIN
tasmota/berry/watch_renaissance/watch_ren_sec_240.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.1 KiB

2354
tasmota/lvgl_berry/be_lv_c_mapping.h
View File

File diff suppressed because it is too large Load Diff

14
tasmota/lvgl_berry/tasmota_lv_conf.h
View File

@ -109,6 +109,7 @@ typedef int16_t lv_coord_t;
# define LV_MEM_CUSTOM_INCLUDE <tasmota_lv_stdlib.h> /*Header for the dynamic memory function*/
# define LV_MEM_CUSTOM_ALLOC lvbe_malloc /*Wrapper to malloc*/ /* PSRAM support */
# define LV_MEM_CUSTOM_FREE lvbe_free /*Wrapper to free*/
# define LV_MEM_CUSTOM_REALLOC lvbe_realloc /*Wrapper to realloc*/
#endif /*LV_MEM_CUSTOM*/
/* Use the standard memcpy and memset instead of LVGL's own functions.
@ -258,6 +259,7 @@ typedef void * lv_fs_drv_user_data_t;
* However the opened images might consume additional RAM.
* Set it to 0 to disable caching */
#define LV_IMG_CACHE_DEF_SIZE 1
#define LV_IMG_CACHE_DEF_SIZE_PSRAM 20 // special Tasmota setting when PSRAM is used
/*Declare the type of the user data of image decoder (can be e.g. `void *`, `int`, `struct`)*/
typedef void * lv_img_decoder_user_data_t;
@ -328,7 +330,7 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i
*===============*/
/*1: Enable the log module*/
#define LV_USE_LOG 0
#define LV_USE_LOG 1
#if LV_USE_LOG
/* How important log should be added:
* LV_LOG_LEVEL_TRACE A lot of logs to give detailed information
@ -337,7 +339,7 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i
* LV_LOG_LEVEL_ERROR Only critical issue, when the system may fail
* LV_LOG_LEVEL_NONE Do not log anything
*/
# define LV_LOG_LEVEL LV_LOG_LEVEL_WARN
# define LV_LOG_LEVEL LV_LOG_LEVEL_ERROR
/* 1: Print the log with 'printf';
* 0: user need to register a callback with `lv_log_register_print_cb`*/
@ -357,7 +359,7 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i
* The behavior of asserts can be overwritten by redefining them here.
* E.g. #define LV_ASSERT_MEM(p) <my_assert_code>
*/
#define LV_USE_DEBUG 1
#define LV_USE_DEBUG 0
#if LV_USE_DEBUG
/*Check if the parameter is NULL. (Quite fast) */
@ -499,13 +501,15 @@ typedef void * lv_font_user_data_t;
* texts and borders will be black and the background will be
* white. Else the colors are inverted.
* No flags. Set LV_THEME_DEFAULT_FLAG 0 */
#define LV_USE_THEME_MONO 1
#define LV_USE_THEME_MONO 0
#define LV_THEME_DEFAULT_INCLUDE <stdint.h> /*Include a header for the init. function*/
#define LV_THEME_DEFAULT_INIT lv_theme_material_init
// #define LV_THEME_DEFAULT_INIT lv_theme_empty_init
#define LV_THEME_DEFAULT_COLOR_PRIMARY lv_color_hex(0x01a2b1)
#define LV_THEME_DEFAULT_COLOR_SECONDARY lv_color_hex(0x44d1b6)
#define LV_THEME_DEFAULT_FLAG LV_THEME_MATERIAL_FLAG_LIGHT
#define LV_THEME_DEFAULT_FLAG LV_THEME_MATERIAL_FLAG_DARK
// #define LV_THEME_DEFAULT_FLAG 0
// #define LV_THEME_DEFAULT_FONT_SMALL &lv_font_montserrat_14
#define LV_THEME_DEFAULT_FONT_SMALL &lv_font_montserrat_10
#define LV_THEME_DEFAULT_FONT_NORMAL &lv_font_montserrat_14

3
tasmota/lvgl_berry/tasmota_lv_stdlib.h
View File

@ -20,4 +20,5 @@
// replacement for <stdlib.h> used for PSRAM malloc in LVGL
extern void *lvbe_malloc(size_t size);
extern void lvbe_free(void *ptr);
extern void lvbe_free(void *ptr);
extern void *lvbe_realloc(void *ptr, size_t size);

43
tasmota/my_user_config.h
View File

@ -928,17 +928,52 @@
#define USE_CSE7761 // Add support for CSE7761 Energy monitor as used in Sonoff Dual R3
// -- LVGL Graphics Library ---------------------------------
//#define USE_LVGL // LVGL Engine, requires Berry, takes 440k of Flash
//#define USE_LVGL // LVGL Engine, requires Berry (+382KB)
#define USE_LVGL_PSRAM // Allocate LVGL memory in PSRAM if PSRAM is connected - this might be slightly slower but leaves main memory intact
#define USE_LVGL_MAX_SLEEP 10 // max sleep in ms when LVGL is enabled, more than 10ms will make display less responsive
//#define USE_LVGL_FREETYPE // Use the FreeType renderer to display fonts using native TTF files in file system (+75k flash)
// WARNING this feature needs to increase the stack size to 32KB, for which there is no easy way right now
#define USE_LVGL_PNG_DECODER // include a PNG image decoder from file system (+16KB)
//#define USE_LVGL_FREETYPE // Use the FreeType renderer to display fonts using native TTF files in file system (+77KB flash)
#define LV_USE_FT_CACHE_MANAGER 1 // define whether glyphs are cached by FreeType library
#define USE_LVGL_FREETYPE_MAX_FACES 64 // max number of FreeType faces in cache
#define USE_LVGL_FREETYPE_MAX_SIZES 4 // max number of sizes in cache
#define USE_LVGL_FREETYPE_MAX_BYTES 16*1024 // max bytes in cache
#define USE_LVGL_FREETYPE_MAX_BYTES_PSRAM 64*1024 // max bytes in cache when using PSRAM
#define USE_LVGL_BG_DEFAULT 0x000000 // Default color for the uninitialized background screen (black)
// Disabling select widgets that will be rarely used in Tasmota (-13KB)
#define BE_LV_WIDGET_ARC 1
#define BE_LV_WIDGET_BAR 1
#define BE_LV_WIDGET_BTN 1
#define BE_LV_WIDGET_BTNMATRIX 1
#define BE_LV_WIDGET_CALENDAR 0
#define BE_LV_WIDGET_CANVAS 1
#define BE_LV_WIDGET_CHART 1
#define BE_LV_WIDGET_CHECKBOX 1
#define BE_LV_WIDGET_CONT 1
#define BE_LV_WIDGET_CPICKER 1
#define BE_LV_WIDGET_DROPDOWN 1
#define BE_LV_WIDGET_GAUGE 1
#define BE_LV_WIDGET_IMG 1
#define BE_LV_WIDGET_IMGBTN 1
#define BE_LV_WIDGET_KEYBOARD 0
#define BE_LV_WIDGET_LABEL 1
#define BE_LV_WIDGET_LED 1
#define BE_LV_WIDGET_LINE 1
#define BE_LV_WIDGET_LINEMETER 1
#define BE_LV_WIDGET_LIST 1
#define BE_LV_WIDGET_MSGBOX 1
#define BE_LV_WIDGET_OBJMASK 1
#define BE_LV_WIDGET_TEMPL 1
#define BE_LV_WIDGET_PAGE 1
#define BE_LV_WIDGET_ROLLER 1
#define BE_LV_WIDGET_SLIDER 1
#define BE_LV_WIDGET_SPINBOX 1
#define BE_LV_WIDGET_SPINNER 1
#define BE_LV_WIDGET_SWITCH 1
#define BE_LV_WIDGET_TABLE 1
#define BE_LV_WIDGET_TABVIEW 1
#define BE_LV_WIDGET_TEXTAREA 1
#define BE_LV_WIDGET_TILEVIEW 1
#define BE_LV_WIDGET_WIN 0
#endif // ESP32

8
tasmota/support.ino
View File

@ -515,12 +515,12 @@ char* UpperCase_P(char* dest, const char* source)
return dest;
}
char* StrCaseStr_P(const char* source, const char* search) {
bool StrCaseStr_P(const char* source, const char* search) {
char case_source[strlen_P(source) +1];
UpperCase_P(case_source, source);
char case_search[strlen_P(search) +1];
UpperCase_P(case_search, search);
return strstr(case_source, case_search);
return (strstr(case_source, case_search) != nullptr);
}
char* Trim(char* p)
@ -1411,7 +1411,7 @@ bool ValidTemplate(const char *search) {
return (strstr(template_name, search_name) != nullptr);
*/
return (StrCaseStr_P(SettingsText(SET_TEMPLATE_NAME), search) != nullptr);
return StrCaseStr_P(SettingsText(SET_TEMPLATE_NAME), search);
}
String AnyModuleName(uint32_t index)
@ -1657,7 +1657,7 @@ bool JsonTemplate(char* dataBuf)
val = root[PSTR(D_JSON_CMND)];
if (val) {
if ((USER_MODULE == Settings.module) || (StrCaseStr_P(val.getStr(), PSTR(D_CMND_MODULE " 0")))) { // Only execute if current module = USER_MODULE = this template
if ((USER_MODULE == Settings.module) || StrCaseStr_P(val.getStr(), PSTR(D_CMND_MODULE " 0"))) { // Only execute if current module = USER_MODULE = this template
char* backup_data = XdrvMailbox.data;
XdrvMailbox.data = (char*)val.getStr(); // Backlog commands
ReplaceChar(XdrvMailbox.data, '|', ';'); // Support '|' as command separator for JSON backwards compatibility

4
tasmota/support_command.ino
View File

@ -240,8 +240,8 @@ void CommandHandler(char* topicBuf, char* dataBuf, uint32_t data_len)
}
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("CMD: " D_GROUP " %d, " D_INDEX " %d, " D_COMMAND " \"%s\", " D_DATA " \"%s\""),
grpflg, index, type, (binary_data) ? HexToString((uint8_t*)dataBuf, data_len).c_str() : dataBuf);
AddLog_P(LOG_LEVEL_DEBUG, PSTR("CMD: Grp %d, Cmnd '%s', Idx %d, Len %d, Data '%s'"),
grpflg, type, index, data_len, (binary_data) ? HexToString((uint8_t*)dataBuf, data_len).c_str() : dataBuf);
if (type != nullptr) {
Response_P(PSTR("{\"" D_JSON_COMMAND "\":\"" D_JSON_ERROR "\"}"));

340
tasmota/xdrv_02_mqtt_1_file.ino
View File

@ -24,6 +24,8 @@
* MQTT file transfer
*
* Supports both binary and base64 encoded binary data transfer
*
* See tools/mqtt-file for python ota-upload and settings-upload and download examples
\*********************************************************************************************/
#include <PubSubClient.h>
@ -41,32 +43,13 @@ struct FMQTT {
String file_md5; // MQTT received file md5 (32 chars)
uint16_t topic_size; // MQTT topic length with terminating <null>
uint8_t file_id = 0; // MQTT unique file id during upload/download
bool file_binary = false; // MQTT binary file transfer
} FMqtt;
/*
The download chunk size is the data size before it is encoded to base64.
It is smaller than the upload chunksize as it is bound by MESSZ
The download buffer with length MESSZ (1042) contains
- Payload ({"Id":117,"Data":"<base64 encoded mqtt_file_chuck_size>"}<null>)
*/
const uint32_t FileTransferHeaderSize = 21; // {"Id":116,"Data":""}<null>
const uint32_t mqtt_file_chuck_size = (((MESSZ - FileTransferHeaderSize) / 4) * 3) -2;
uint32_t FileUploadChunckSize(void) {
/*
The upload chunk size is the data size of the payload.
It can be larger than the download chunksize which is bound by MESSZ
The PubSubClient upload buffer with length MQTT_MAX_PACKET_SIZE (1200) contains
- Header of 5 bytes (MQTT_MAX_HEADER_SIZE)
- Topic string terminated with a zero (stat/demo/FILEUPLOAD<null>)
- Payload ({"Id":116,"Data":"<base64 encoded FileUploadChunckSize>"}<null>) or (<binary data>)
*/
const uint32_t PubSubClientHeaderSize = 5; // MQTT_MAX_HEADER_SIZE
return MqttClient.getBufferSize() - PubSubClientHeaderSize - FMqtt.topic_size -1;
}
uint32_t MqttFileUploadValidate(uint32_t rcv_id) {
if (XdrvMailbox.grpflg) { return 5; }
if (XdrvMailbox.grpflg) { return 5; } // No grouptopic supported
if ((0 == FMqtt.file_id) && (rcv_id > 0) && (FMqtt.file_size > 0) && (FMqtt.file_type > 0)) {
FMqtt.file_buffer = nullptr; // Init upload buffer
@ -77,7 +60,7 @@ uint32_t MqttFileUploadValidate(uint32_t rcv_id) {
// Check buffer size
if (UPL_SETTINGS == FMqtt.file_type) {
if (FMqtt.file_size > 4096) {
if (FMqtt.file_size > sizeof(Settings)) {
return 2; // Settings supports max 4k size
}
} else { // Check enough flash space for intermediate upload
@ -89,22 +72,31 @@ uint32_t MqttFileUploadValidate(uint32_t rcv_id) {
}
// Init file_buffer
if (UPL_TASMOTA == FMqtt.file_type) {
if (Update.begin(FMqtt.file_size)) {
FMqtt.file_buffer = &FMqtt.file_id; // Dummy buffer
// TasmotaGlobal.blinkstate = true; // Stay lit
SettingsSave(1); // Free flash for OTA update
}
}
else if (UPL_SETTINGS == FMqtt.file_type) {
if (UPL_SETTINGS == FMqtt.file_type) {
if (SettingsConfigBackup()) {
FMqtt.file_buffer = settings_buffer;
}
}
else {
return 3; // Invalid file type
if (UPL_TASMOTA == FMqtt.file_type) {
if (Update.begin(FMqtt.file_size)) {
FMqtt.file_buffer = &FMqtt.file_id; // Dummy buffer
// FMqtt.file_buffer = (uint8_t*)malloc(SPI_FLASH_SEC_SIZE);
// if (FMqtt.file_buffer) {
SetLedLink(1);
SettingsSave(1); // Free flash for OTA update
// }
} else {
Update.end(true);
}
}
else {
return 3; // Invalid file type
}
}
if (!FMqtt.file_buffer) { return 6; } // No buffer
FMqtt.file_id = rcv_id;
FMqtt.file_pos = 0;
@ -114,20 +106,61 @@ uint32_t MqttFileUploadValidate(uint32_t rcv_id) {
ResponseCmndChar(PSTR(D_JSON_STARTED));
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command); // Enforce stat/wemos10/FILEUPLOAD
}
else if ((FMqtt.file_id > 0) && (FMqtt.file_id != rcv_id)) {
else if (((FMqtt.file_id > 0) && (FMqtt.file_id != rcv_id)) || (0 == XdrvMailbox.payload)) {
// Error receiving data
if (UPL_TASMOTA == FMqtt.file_type) {
Update.end(true);
}
else if (UPL_SETTINGS == FMqtt.file_type) {
if (UPL_SETTINGS == FMqtt.file_type) {
SettingsBufferFree();
}
else {
if (UPL_TASMOTA == FMqtt.file_type) {
Update.end(true);
SetLedLink(0);
}
/*
if (FMqtt.file_buffer != nullptr) {
free(FMqtt.file_buffer);
FMqtt.file_buffer = nullptr;
}
*/
}
return 4; // Upload aborted
}
return 0; // No error
}
void MqttFileValidate(uint32_t error) {
if (error) {
FMqtt.file_buffer = nullptr;
MqttDisableLogging(false);
if (4 == error) {
ResponseCmndChar(PSTR(D_JSON_ABORTED));
} else {
char error_txt[20];
snprintf_P(error_txt, sizeof(error_txt), PSTR(D_JSON_ERROR " %d"), error);
ResponseCmndChar(error_txt);
}
}
}
void MqttFilePublish(void) {
if (!FMqtt.file_buffer) {
MqttDisableLogging(false);
FMqtt.file_id = 0;
FMqtt.file_size = 0;
FMqtt.file_type = 0;
FMqtt.file_binary = false;
FMqtt.file_md5 = (const char*) nullptr; // Force deallocation of the String internal memory
FMqtt.file_password = nullptr;
}
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command);
ResponseClear();
}
void CmndFileUpload(void) {
/*
Upload <MaxSize> bytes chunks of data either base64 encoded or binary with MD5 hash
@ -152,13 +185,12 @@ void CmndFileUpload(void) {
*/
const char* base64_data = nullptr;
uint32_t rcv_id = 0;
char* dataBuf = (char*)XdrvMailbox.data;
bool binary_data = (XdrvMailbox.index > 199); // Check for raw data
if (!binary_data) {
if (strlen(dataBuf) > 8) { // Workaround exception if empty JSON like {} - Needs checks
JsonParser parser((char*) dataBuf);
if (strlen(XdrvMailbox.data) > 8) { // Workaround exception if empty JSON like {} - Needs checks
JsonParser parser((char*) XdrvMailbox.data);
JsonParserObject root = parser.getRootObject();
if (root) {
JsonParserToken val = root[PSTR("ID")];
@ -178,17 +210,7 @@ void CmndFileUpload(void) {
} else {
rcv_id = FMqtt.file_id;
}
uint32_t error = MqttFileUploadValidate(rcv_id);
if (error) {
FMqtt.file_buffer = nullptr;
TasmotaGlobal.masterlog_level = LOG_LEVEL_NONE; // Enable logging
char error_txt[20];
snprintf_P(error_txt, sizeof(error_txt), PSTR(D_JSON_ERROR " %d"), error);
ResponseCmndChar(error_txt);
}
MqttFileValidate(MqttFileUploadValidate(rcv_id));
if (FMqtt.file_buffer) {
if ((FMqtt.file_pos < FMqtt.file_size) && (binary_data || base64_data)) {
@ -208,12 +230,15 @@ void CmndFileUpload(void) {
uint32_t read_bytes = (bytes_left < rcvd_bytes) ? bytes_left : rcvd_bytes;
FMqtt.md5.add(raw_data, read_bytes);
if (UPL_TASMOTA == FMqtt.file_type) {
Update.write(raw_data, read_bytes);
} else {
if (UPL_SETTINGS == FMqtt.file_type) {
uint8_t* buffer = FMqtt.file_buffer + FMqtt.file_pos;
memcpy(buffer, raw_data, read_bytes);
}
else {
if (UPL_TASMOTA == FMqtt.file_type) {
Update.write(raw_data, read_bytes);
}
}
if (!binary_data) {
free(raw_data);
@ -223,16 +248,25 @@ void CmndFileUpload(void) {
}
if ((FMqtt.file_pos > rcvd_bytes) && ((FMqtt.file_pos % 102400) <= rcvd_bytes)) {
TasmotaGlobal.masterlog_level = LOG_LEVEL_NONE; // Enable logging
TasmotaGlobal.masterlog_level = LOG_LEVEL_NONE; // Enable logging
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_UPLOAD "Progress %d kB"), (FMqtt.file_pos / 10240) * 10);
TasmotaGlobal.masterlog_level = LOG_LEVEL_DEBUG_MORE; // Hide upload data logging
}
}
if ((FMqtt.file_pos < FMqtt.file_size) || (FMqtt.file_md5.length() != 32)) {
TasmotaGlobal.masterlog_level = LOG_LEVEL_DEBUG_MORE; // Hide upload data logging
MqttDisableLogging(true);
uint32_t chunk_size = FileUploadChunckSize();
/*
The upload chunk size is the data size of the payload.
It can be larger than the download chunksize which is bound by MESSZ
The PubSubClient upload buffer with length MQTT_MAX_PACKET_SIZE (1200) contains
- Header of 5 bytes (MQTT_MAX_HEADER_SIZE)
- Topic string terminated with a zero (stat/demo/FILEUPLOAD<null>)
- Payload ({"Id":116,"Data":"<base64 encoded chunk_size>"}<null>) or (<binary data>)
*/
const uint32_t PubSubClientHeaderSize = 5; // MQTT_MAX_HEADER_SIZE
uint32_t chunk_size = MqttClient.getBufferSize() - PubSubClientHeaderSize - FMqtt.topic_size -1;
if (!binary_data) {
chunk_size = (((chunk_size - FileTransferHeaderSize) / 4) * 3) -2; // Calculate base64 chunk size
}
@ -246,115 +280,165 @@ void CmndFileUpload(void) {
// Process upload data en free buffer
ResponseCmndDone();
if (UPL_TASMOTA == FMqtt.file_type) {
if (!Update.end(true)) {
ResponseCmndFailed();
} else {
TasmotaGlobal.restart_flag = 2; // Always restart to re-enable disabled features during update
}
}
else if (UPL_SETTINGS == FMqtt.file_type) {
if (UPL_SETTINGS == FMqtt.file_type) {
if (!SettingsConfigRestore()) {
ResponseCmndFailed();
} else {
TasmotaGlobal.restart_flag = 2; // Always restart to re-enable disabled features during update
TasmotaGlobal.restart_flag = 2; // Restart to load new settings
}
}
else {
if (UPL_TASMOTA == FMqtt.file_type) {
if (!Update.end(true)) {
SetLedLink(0);
ResponseCmndFailed();
} else {
TasmotaGlobal.restart_flag = 2; // Restart to load new firmware
}
}
/*
if (FMqtt.file_buffer != nullptr) {
free(FMqtt.file_buffer);
FMqtt.file_buffer = nullptr;
}
*/
}
}
FMqtt.file_buffer = nullptr;
}
}
if (!FMqtt.file_buffer) {
TasmotaGlobal.masterlog_level = LOG_LEVEL_NONE; // Enable logging
FMqtt.file_id = 0;
FMqtt.file_size = 0;
FMqtt.file_type = 0;
FMqtt.file_md5 = (const char*) nullptr; // Force deallocation of the String internal memory
FMqtt.file_password = nullptr;
MqttFilePublish();
}
uint32_t MqttFileDownloadValidate(void) {
if (XdrvMailbox.grpflg) { return 5; } // No grouptopic supported
if ((0 == FMqtt.file_id) && (FMqtt.file_type > 0)) {
FMqtt.file_buffer = nullptr; // Init upload buffer
if (!FMqtt.file_password || (strcmp(FMqtt.file_password, SettingsText(SET_MQTT_PWD)) != 0)) {
return 1; // Invalid password
}
FMqtt.file_id = (UtcTime() & 0xFE) +1; // Odd id between 1 and 255
// Init file_buffer
if (UPL_SETTINGS == FMqtt.file_type) {
uint32_t len = SettingsConfigBackup();
if (!len) { return 2; }
FMqtt.file_type = UPL_SETTINGS;
FMqtt.file_buffer = settings_buffer;
FMqtt.file_size = len;
// {"File":"Config_wemos10_9.4.0.3.dmp","Id":117,"Type":2,"Size":4096}
Response_P(PSTR("{\"File\":\"%s\",\"Id\":%d,\"Type\":%d,\"Size\":%d}"),
SettingsConfigFilename().c_str(), FMqtt.file_id, FMqtt.file_type, len);
}
else {
return 3; // Invalid file type
}
FMqtt.file_pos = 0;
FMqtt.md5 = MD5Builder();
FMqtt.md5.begin();
char payload[50];
snprintf_P(payload, sizeof(payload), S_JSON_COMMAND_SVALUE, XdrvMailbox.command, PSTR(D_JSON_STARTED));
MqttPublishPayloadPrefixTopic_P(STAT, XdrvMailbox.command, payload); // Enforce stat/wemos10/FILEUPLOAD
MqttDisableLogging(true);
}
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command); // Enforce stat/wemos10/FILEUPLOAD
ResponseClear();
else if (0 == XdrvMailbox.payload) {
if (UPL_SETTINGS == FMqtt.file_type) {
SettingsBufferFree();
}
return 4; // Upload aborted
}
return 0; // No error
}
void CmndFileDownload(void) {
/*
Download (binary) max 700 bytes chunks of data base64 encoded with MD5 hash over base64 decoded data
Currently supports Settings (file type 2)
Filedownload 0 - Abort current download
FileDownload 2 - Start download of settings file
FileDownload - Continue downloading data until reception of MD5 hash
Download chunks of data base64 encoded with MD5 hash
Supported Type:
2 - Settings
FileDownload 0 - Abort current download
Start a download session:
FileDownload {"Password":"","Type":2}
Download data using base64 until reception of MD5 hash:
FileDownload
*/
if (XdrvMailbox.grpflg) { return; }
if (FMqtt.file_id && FMqtt.file_buffer) {
bool finished = false;
if (0 == XdrvMailbox.payload) { // Abort file download
ResponseCmndChar(PSTR(D_JSON_ABORTED));
finished = true;
}
else if (FMqtt.file_pos < FMqtt.file_size) {
if (FMqtt.file_buffer) {
if (FMqtt.file_pos < FMqtt.file_size) {
uint32_t bytes_left = FMqtt.file_size - FMqtt.file_pos;
uint32_t write_bytes = (bytes_left < mqtt_file_chuck_size) ? bytes_left : mqtt_file_chuck_size;
/*
The download chunk size is the data size before it is encoded to base64.
It is smaller than the upload chunksize as it is bound by MESSZ
The download buffer with length MESSZ (1042) contains
- Payload ({"Id":117,"Data":"<base64 encoded mqtt_file_chuck_size>"}<null>)
*/
const uint32_t mqtt_file_chunk_size = (((MESSZ - FileTransferHeaderSize) / 4) * 3) -2;
uint32_t chunk_size = (FMqtt.file_binary) ? 4096 : mqtt_file_chunk_size;
uint32_t write_bytes = (bytes_left < chunk_size) ? bytes_left : chunk_size;
uint8_t* buffer = FMqtt.file_buffer + FMqtt.file_pos;
FMqtt.md5.add(buffer, write_bytes);
// {"Id":117,"Data":"CRJcTQ9fYGF ... OT1BRUlNUVVZXWFk="}
Response_P(PSTR("{\"Id\":%d,\"Data\":\""), FMqtt.file_id); // FileTransferHeaderSize
char base64_data[encode_base64_length(write_bytes)];
encode_base64((unsigned char*)buffer, write_bytes, (unsigned char*)base64_data);
ResponseAppend_P(base64_data);
ResponseAppend_P("\"}");
FMqtt.file_pos += write_bytes;
if (FMqtt.file_binary) {
MqttPublishPayloadPrefixTopic_P(STAT, XdrvMailbox.command, (const char*)buffer, write_bytes);
} else {
// {"Id":117,"Data":"CRJcTQ9fYGF ... OT1BRUlNUVVZXWFk="}
Response_P(PSTR("{\"Id\":%d,\"Data\":\""), FMqtt.file_id); // FileTransferHeaderSize
char base64_data[encode_base64_length(write_bytes)];
encode_base64((unsigned char*)buffer, write_bytes, (unsigned char*)base64_data);
ResponseAppend_P(base64_data);
ResponseAppend_P("\"}");
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command);
}
ResponseClear();
return;
} else {
FMqtt.md5.calculate();
// {"Id":117,"Md5":"496fcbb433bbca89833063174d2c5747"}
Response_P(PSTR("{\"Id\":%d,\"Md5\":\"%s\"}"), FMqtt.file_id, FMqtt.md5.toString().c_str());
finished = true;
}
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command); // Enforce stat/wemos10/FILEUPLOAD
ResponseCmndDone();
if (finished) {
if (UPL_SETTINGS == FMqtt.file_type) {
SettingsBufferFree();
}
FMqtt.file_id = 0;
FMqtt.file_buffer = nullptr;
}
}
else if (XdrvMailbox.data_len) {
FMqtt.file_buffer = nullptr;
FMqtt.file_id = (UtcTime() & 0xFE) +1; // Odd id between 1 and 255
if (UPL_SETTINGS == XdrvMailbox.payload) {
uint32_t len = SettingsConfigBackup();
if (len) {
FMqtt.file_type = UPL_SETTINGS;
FMqtt.file_buffer = settings_buffer;
FMqtt.file_size = len;
// {"File":"Config_wemos10_9.4.0.3.dmp","Id":117,"Type":2,"Size":4096}
Response_P(PSTR("{\"File\":\"%s\",\"Id\":%d,\"Type\":%d,\"Size\":%d}"),
SettingsConfigFilename().c_str(), FMqtt.file_id, FMqtt.file_type, len);
}
}
if (FMqtt.file_buffer) {
FMqtt.file_pos = 0;
FMqtt.md5 = MD5Builder();
FMqtt.md5.begin();
} else {
FMqtt.file_id = 0;
ResponseCmndFailed();
if (strlen(XdrvMailbox.data) > 8) { // Workaround exception if empty JSON like {} - Needs checks
JsonParser parser((char*) XdrvMailbox.data);
JsonParserObject root = parser.getRootObject();
if (root) {
JsonParserToken val = root[PSTR("TYPE")];
if (val) { FMqtt.file_type = val.getUInt(); }
val = root[PSTR("BINARY")];
if (val) { FMqtt.file_binary = val.getUInt(); }
val = root[PSTR("PASSWORD")];
if (val) { FMqtt.file_password = val.getStr(); }
}
}
MqttPublishPrefixTopic_P(STAT, XdrvMailbox.command);
ResponseClear();
MqttFileValidate(MqttFileDownloadValidate());
MqttFilePublish();
}
#endif // USE_MQTT_FILE

139
tasmota/xdrv_02_mqtt_9_impl.ino
View File

@ -108,6 +108,7 @@ struct MQTT {
bool connected = false; // MQTT virtual connection status
bool allowed = false; // MQTT enabled and parameters valid
bool mqtt_tls = false; // MQTT TLS is enabled
bool disable_logging = false; // Temporarly disable logging on some commands
} Mqtt;
#ifdef USE_MQTT_TLS
@ -173,13 +174,19 @@ void MakeValidMqtt(uint32_t option, char* str) {
}
}
void MqttDisableLogging(bool state) {
// Disable logging only on repeating MQTT messages
Mqtt.disable_logging = state;
TasmotaGlobal.masterlog_level = (Mqtt.disable_logging) ? LOG_LEVEL_DEBUG_MORE : LOG_LEVEL_NONE;
}
/*********************************************************************************************\
* MQTT driver specific code need to provide the following functions:
*
* bool MqttIsConnected()
* void MqttDisconnect()
* void MqttSubscribeLib(char *topic)
* bool MqttPublishLib(const char* topic, bool retained)
* bool MqttPublishLib(const char* topic, const uint8_t* payload, unsigned int plength, bool retained)
\*********************************************************************************************/
#include <PubSubClient.h>
@ -465,7 +472,7 @@ void MqttUnsubscribeLib(const char *topic) {
MqttClient.loop(); // Solve LmacRxBlk:1 messages
}
bool MqttPublishLib(const char* topic, bool retained) {
bool MqttPublishLib(const char* topic, const uint8_t* payload, unsigned int plength, bool retained) {
// If Prefix1 equals Prefix2 disable next MQTT subscription to prevent loop
if (!strcmp(SettingsText(SET_MQTTPREFIX1), SettingsText(SET_MQTTPREFIX2))) {
char *str = strstr(topic, SettingsText(SET_MQTTPREFIX1));
@ -475,35 +482,34 @@ bool MqttPublishLib(const char* topic, bool retained) {
}
}
bool result;
#ifdef USE_MQTT_AZURE_IOT
String sourceTopicString = urlEncodeBase64(String(topic));
String topicString = "devices/" + String(SettingsText(SET_MQTT_CLIENT));
topicString+= "/messages/events/topic=" + sourceTopicString;
topicString += "/messages/events/topic=" + sourceTopicString;
JsonParser mqtt_message((char*) String(TasmotaGlobal.mqtt_data).c_str());
JsonParser mqtt_message((char*) String((const char*)payload).c_str());
JsonParserObject message_object = mqtt_message.getRootObject();
if (message_object.isValid()) { // only sending valid JSON, yet this is optional
result = MqttClient.publish(topicString.c_str(), TasmotaGlobal.mqtt_data, retained);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Sending '%s'"), TasmotaGlobal.mqtt_data);
} else {
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Invalid JSON, '%s' for topic '%s', not sending to Azure IoT Hub"), TasmotaGlobal.mqtt_data, topic);
result = true;
if (!message_object.isValid()) { // only sending valid JSON, yet this is optional
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Invalid JSON for topic '%s', not sending to Azure IoT Hub"), topic);
return true;
}
#else
result = MqttClient.publish(topic, TasmotaGlobal.mqtt_data, retained);
topic = topicString.c_str();
#endif // USE_MQTT_AZURE_IOT
yield(); // #3313
return result;
}
#ifdef DEBUG_TASMOTA_CORE
void MqttDumpData(char* topic, char* data, uint32_t data_len) {
char dump_data[data_len +1];
memcpy(dump_data, data, sizeof(dump_data)); // Make another copy for removing optional control characters
DEBUG_CORE_LOG(PSTR(D_LOG_MQTT "Size %d, \"%s %s\""), data_len, topic, RemoveControlCharacter(dump_data));
if (!MqttClient.beginPublish(topic, plength, retained)) {
// AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Connection lost or message too large"));
return false;
}
uint32_t written = MqttClient.write(payload, plength);
if (written != plength) {
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Message too large"));
return false;
}
MqttClient.endPublish();
yield(); // #3313
return true;
}
#endif
void MqttDataHandler(char* mqtt_topic, uint8_t* mqtt_data, unsigned int data_len) {
#ifdef USE_DEBUG_DRIVER
@ -554,9 +560,9 @@ void MqttDataHandler(char* mqtt_topic, uint8_t* mqtt_data, unsigned int data_len
char data[data_len +1];
memcpy(data, mqtt_data, sizeof(data));
#ifdef DEBUG_TASMOTA_CORE
MqttDumpData(topic, data, data_len); // Use a function to save stack space used by dump_data
#endif
if (Mqtt.disable_logging) {
TasmotaGlobal.masterlog_level = LOG_LEVEL_DEBUG_MORE; // Hide logging
}
// MQTT pre-processing
XdrvMailbox.index = strlen(topic);
@ -568,6 +574,10 @@ void MqttDataHandler(char* mqtt_topic, uint8_t* mqtt_data, unsigned int data_len
ShowSource(SRC_MQTT);
CommandHandler(topic, data, data_len);
if (Mqtt.disable_logging) {
TasmotaGlobal.masterlog_level = LOG_LEVEL_NONE; // Enable logging
}
}
/*********************************************************************************************/
@ -598,21 +608,28 @@ void MqttPublishLoggingAsync(bool refresh) {
strlcpy(TasmotaGlobal.mqtt_data, line, len); // No JSON and ugly!!
char stopic[TOPSZ];
GetTopic_P(stopic, STAT, TasmotaGlobal.mqtt_topic, PSTR("LOGGING"));
MqttPublishLib(stopic, false);
MqttPublishLib(stopic, (const uint8_t*)TasmotaGlobal.mqtt_data, strlen(TasmotaGlobal.mqtt_data), false);
}
}
void MqttPublish(const char* topic, bool retained) {
void MqttPublishPayload(const char* topic, const char* payload, uint32_t binary_length, bool retained) {
// Publish <topic> payload string or binary when binary_length set with optional retained
#ifdef USE_DEBUG_DRIVER
ShowFreeMem(PSTR("MqttPublish"));
#endif
bool binary_data = (binary_length > 0);
if (!binary_data) {
binary_length = strlen(payload);
}
if (Settings.flag4.mqtt_no_retain) { // SetOption104 - Disable all MQTT retained messages, some brokers don't support it: AWS IoT, Losant
retained = false; // Some brokers don't support retained, they will disconnect if received
}
String log_data; // 20210420 Moved to heap to solve tight stack resulting in exception 2
if (Settings.flag.mqtt_enabled && MqttPublishLib(topic, retained)) { // SetOption3 - Enable MQTT
if (Settings.flag.mqtt_enabled && MqttPublishLib(topic, (const uint8_t*)payload, binary_length, retained)) { // SetOption3 - Enable MQTT
log_data = F(D_LOG_MQTT); // MQT:
log_data += topic; // stat/tasmota/STATUS2
} else {
@ -621,7 +638,7 @@ void MqttPublish(const char* topic, bool retained) {
retained = false; // Without MQTT enabled there is no retained message
}
log_data += F(" = "); // =
log_data += TasmotaGlobal.mqtt_data; // {"StatusFWR":{"Version":...
log_data += (binary_data) ? HexToString((uint8_t*)payload, binary_length) : payload;
if (retained) { log_data += F(" (" D_RETAINED ")"); } // (retained)
AddLogData(LOG_LEVEL_INFO, log_data.c_str()); // MQT: stat/tasmota/STATUS2 = {"StatusFWR":{"Version":...
@ -630,18 +647,32 @@ void MqttPublish(const char* topic, bool retained) {
}
}
void MqttPublishPayload(const char* topic, const char* payload) {
// Publish <topic> payload string no retained
MqttPublishPayload(topic, payload, 0, false);
}
void MqttPublish(const char* topic, bool retained) {
// Publish <topic> default TasmotaGlobal.mqtt_data string with optional retained
MqttPublishPayload(topic, TasmotaGlobal.mqtt_data, 0, retained);
}
void MqttPublish(const char* topic) {
// Publish <topic> default TasmotaGlobal.mqtt_data string no retained
MqttPublish(topic, false);
}
void MqttPublishPrefixTopic_P(uint32_t prefix, const char* subtopic, bool retained) {
/* prefix 0 = cmnd using subtopic
* prefix 1 = stat using subtopic
* prefix 2 = tele using subtopic
* prefix 4 = cmnd using subtopic or RESULT
* prefix 5 = stat using subtopic or RESULT
* prefix 6 = tele using subtopic or RESULT
*/
void MqttPublishPayloadPrefixTopic_P(uint32_t prefix, const char* subtopic, const char* payload, uint32_t binary_length, bool retained) {
/*
Publish <prefix>/<device>/<RESULT or <subtopic>> payload string or binary when binary_length set with optional retained
prefix 0 = cmnd using subtopic
prefix 1 = stat using subtopic
prefix 2 = tele using subtopic
prefix 4 = cmnd using subtopic or RESULT
prefix 5 = stat using subtopic or RESULT
prefix 6 = tele using subtopic or RESULT
*/
char romram[64];
snprintf_P(romram, sizeof(romram), ((prefix > 3) && !Settings.flag.mqtt_response) ? S_RSLT_RESULT : subtopic); // SetOption4 - Switch between MQTT RESULT or COMMAND
UpperCase(romram, romram);
@ -649,7 +680,7 @@ void MqttPublishPrefixTopic_P(uint32_t prefix, const char* subtopic, bool retain
prefix &= 3;
char stopic[TOPSZ];
GetTopic_P(stopic, prefix, TasmotaGlobal.mqtt_topic, romram);
MqttPublish(stopic, retained);
MqttPublishPayload(stopic, payload, binary_length, retained);
#if defined(USE_MQTT_AWS_IOT) || defined(USE_MQTT_AWS_IOT_LIGHT)
if ((prefix > 0) && (Settings.flag4.awsiot_shadow) && (Mqtt.connected)) { // placeholder for SetOptionXX
@ -669,33 +700,53 @@ void MqttPublishPrefixTopic_P(uint32_t prefix, const char* subtopic, bool retain
snprintf_P(romram, sizeof(romram), PSTR("$aws/things/%s/shadow/update"), topic2);
// copy buffer
char *mqtt_save = (char*) malloc(strlen(TasmotaGlobal.mqtt_data)+1);
if (!mqtt_save) { return; } // abort
strcpy(mqtt_save, TasmotaGlobal.mqtt_data);
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"state\":{\"reported\":%s}}"), mqtt_save);
free(mqtt_save);
String aws_payload = F("{\"state\":{\"reported\":%s}}");
aws_payload += payload;
MqttClient.publish(romram, aws_payload.c_str(), false);
bool result = MqttClient.publish(romram, TasmotaGlobal.mqtt_data, false);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_MQTT "Updated shadow: %s"), romram);
yield(); // #3313
}
#endif // USE_MQTT_AWS_IOT
}
void MqttPublishPayloadPrefixTopic_P(uint32_t prefix, const char* subtopic, const char* payload, uint32_t binary_length) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> payload string or binary when binary_length set no retained
MqttPublishPayloadPrefixTopic_P(prefix, subtopic, payload, binary_length, false);
}
void MqttPublishPayloadPrefixTopic_P(uint32_t prefix, const char* subtopic, const char* payload) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> payload string no retained
MqttPublishPayloadPrefixTopic_P(prefix, subtopic, payload, 0, false);
}
void MqttPublishPrefixTopic_P(uint32_t prefix, const char* subtopic, bool retained) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> default TasmotaGlobal.mqtt_data string with optional retained
MqttPublishPayloadPrefixTopic_P(prefix, subtopic, TasmotaGlobal.mqtt_data, 0, retained);
}
void MqttPublishPrefixTopic_P(uint32_t prefix, const char* subtopic) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> default TasmotaGlobal.mqtt_data string no retained
MqttPublishPrefixTopic_P(prefix, subtopic, false);
}
void MqttPublishPrefixTopicRulesProcess_P(uint32_t prefix, const char* subtopic, bool retained) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> default TasmotaGlobal.mqtt_data string with optional retained
// then process rules
MqttPublishPrefixTopic_P(prefix, subtopic, retained);
XdrvRulesProcess(0);
}
void MqttPublishPrefixTopicRulesProcess_P(uint32_t prefix, const char* subtopic) {
// Publish <prefix>/<device>/<RESULT or <subtopic>> default TasmotaGlobal.mqtt_data string no retained
// then process rules
MqttPublishPrefixTopicRulesProcess_P(prefix, subtopic, false);
}
void MqttPublishTeleSensor(void) {
// Publish tele/<device>/SENSOR default TasmotaGlobal.mqtt_data string with optional retained
// then process rules
MqttPublishPrefixTopicRulesProcess_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain); // CMND_SENSORRETAIN
}

11
tasmota/xdrv_07_domoticz.ino
View File

@ -360,8 +360,9 @@ bool DomoticzSendKey(uint8_t key, uint8_t device, uint8_t state, uint8_t svalflg
\*********************************************************************************************/
void DomoticzSendData(uint32_t sensor_idx, uint32_t idx, char *data) {
char payload[128];
if (DZ_AIRQUALITY == sensor_idx) {
Response_P(PSTR("{\"idx\":%d,\"nvalue\":%s,\"Battery\":%d,\"RSSI\":%d}"),
snprintf_P(payload, sizeof(payload), PSTR("{\"idx\":%d,\"nvalue\":%s,\"Battery\":%d,\"RSSI\":%d}"),
idx, data, DomoticzBatteryQuality(), DomoticzRssiQuality());
} else {
uint8_t nvalue = 0;
@ -371,19 +372,15 @@ void DomoticzSendData(uint32_t sensor_idx, uint32_t idx, char *data) {
nvalue = position < 2 ? 0 : (position == 100 ? 1 : 2);
}
#endif // USE_SHUTTER
Response_P(DOMOTICZ_MESSAGE, // "{\"idx\":%d,\"nvalue\":%d,\"svalue\":\"%s\",\"Battery\":%d,\"RSSI\":%d}"
snprintf_P(payload, sizeof(payload), DOMOTICZ_MESSAGE, // "{\"idx\":%d,\"nvalue\":%d,\"svalue\":\"%s\",\"Battery\":%d,\"RSSI\":%d}"
idx, nvalue, data, DomoticzBatteryQuality(), DomoticzRssiQuality());
}
MqttPublish(domoticz_in_topic);
MqttPublishPayload(domoticz_in_topic, payload);
}
void DomoticzSensor(uint8_t idx, char *data) {
if (Settings.domoticz_sensor_idx[idx]) {
char dmess[128]; // {"idx":26700,"nvalue":0,"svalue":"22330.1;10234.4;22000.5;10243.4;1006;3000","Battery":100,"RSSI":10}
memcpy(dmess, TasmotaGlobal.mqtt_data, sizeof(dmess));
DomoticzSendData(idx, Settings.domoticz_sensor_idx[idx], data);
memcpy(TasmotaGlobal.mqtt_data, dmess, sizeof(dmess));
}
}

5
tasmota/xdrv_10_scripter.ino
View File

@ -8386,11 +8386,6 @@ bool Xdrv10(uint8_t function)
case FUNC_EVERY_100_MSECOND:
ScripterEvery100ms();
break;
#ifdef USE_LVGL
case FUNC_EVERY_50_MSECOND:
lv_task_handler();
break;
#endif // USE_LVGL
case FUNC_EVERY_SECOND:
ScriptEverySecond();

296
tasmota/xdrv_52_3_berry_lvgl.ino
View File

@ -23,6 +23,7 @@
#include <berry.h>
#include "lvgl.h"
#include "be_lvgl.h"
#include "Adafruit_LvGL_Glue.h"
#ifdef USE_LVGL_FREETYPE
@ -30,6 +31,11 @@
#include "lv_freetype.h"
#endif
// Berry easy logging
extern "C" {
extern void berry_log_C(const char * berry_buf, ...);
}
extern Adafruit_LvGL_Glue * glue;
/********************************************************************
@ -273,32 +279,169 @@ void be_check_arg_type(bvm *vm, int32_t argc, const char * arg_type, int32_t p[5
}
typedef int32_t (*fn_any_callable)(int32_t p0, int32_t p1, int32_t p2, int32_t p3, int32_t p4);
int be_call_c_func(bvm *vm, void * func, const char * return_type = nullptr, const char * arg_type = nullptr) {
int32_t p[5] = {0,0,0,0,0};
int32_t argc = be_top(vm); // Get the number of arguments
extern "C" {
fn_any_callable f = (fn_any_callable) func;
be_check_arg_type(vm, argc, arg_type, p);
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func(%p) - %p,%p,%p,%p,%p - %s", f, p[0], p[1], p[2], p[3], p[4], return_type);
int32_t ret = (*f)(p[0], p[1], p[2], p[3], p[4]);
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func, ret = %p", ret);
if ((return_type == nullptr) || (strlen(return_type) == 0)) { be_return_nil(vm); } // does not return
else if (strlen(return_type) == 1) {
switch (return_type[0]) {
case 'i': be_pushint(vm, ret); break;
case 'b': be_pushbool(vm, ret); break;
case 's': be_pushstring(vm, (const char*) ret); break;
default: be_raise(vm, "internal_error", "Unsupported return type"); break;
void lv_init_set_member(bvm *vm, int index, void * ptr);
// called programmatically
int lvx_init_2(bvm *vm, void * func, const char * return_type, const char * arg_type = nullptr);
int lvx_init_2(bvm *vm, void * func, const char * return_type, const char * arg_type) {
int argc = be_top(vm);
lv_obj_t * obj1 = nullptr;
lv_obj_t * obj2 = nullptr;
if (argc > 1) {
obj1 = (lv_obj_t*) be_convert_single_elt(vm, 2);
}
if (argc > 2) {
obj2 = (lv_obj_t*) be_convert_single_elt(vm, 3);
}
// AddLog(LOG_LEVEL_INFO, "argc %d lv_obj %p", argc, obj);
fn_any_callable f = (fn_any_callable) func;
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func(%p) - %p,%p,%p,%p,%p", f, p[0], p[1], p[2], p[3], p[4]);
lv_obj_t * obj;
if ((int32_t)obj1 == -1) { // special semantics of first ptr is -1, then just encapsulate
obj = obj2;
} else { // otherwise call the LVGL creator
obj = (lv_obj_t*) (*f)((int32_t)obj1, (int32_t)obj2, 0, 0, 0);
}
lv_init_set_member(vm, 1, obj);
be_return_nil(vm);
}
// binary search within an array of sorted strings
// the first 4 bytes are a pointer to a string
// returns 0..total_elements-1 or -1 if not found
int32_t bin_search(const char * needle, const void * table, size_t elt_size, size_t total_elements) {
int32_t low = 0;
int32_t high = total_elements - 1;
int32_t mid = (low + high) / 2;
// start a dissect
while (low <= high) {
const char * elt = *(const char **) ( ((uint8_t*)table) + mid * elt_size );
int32_t comp = strcmp(needle, elt);
if (comp < 0) {
high = mid - 1;
} else if (comp > 0) {
low = mid + 1;
} else {
break;
}
mid = (low + high) / 2;
}
if (low <= high) {
return mid;
} else {
return -1;
}
}
int be_call_c_func(bvm *vm, void * func, const char * return_type, const char * arg_type);
// native closure to call `be_call_c_func`
int lvx_call_c(bvm *vm) {
// keep parameters unchanged
be_getupval(vm, 0, 0); // if index is zero, it's the current native closure
void * func = be_tocomptr(vm, -1);
be_getupval(vm, 0, 1); // if index is zero, it's the current native closure
const char * return_type = be_tostring(vm, -1);
be_getupval(vm, 0, 2); // if index is zero, it's the current native closure
const char * arg_type = be_tostring(vm, -1);
be_pop(vm, 3); // remove 3 upvals
// berry_log_C("lvx_call_c %p '%s' <- (%s)", func, return_type, arg_type);
return be_call_c_func(vm, func, return_type, arg_type);
}
// virtual method, arg1: instance, arg2: name of method
int lvx_member(bvm *vm) {
int32_t argc = be_top(vm); // Get the number of arguments
if (argc == 2 && be_isinstance(vm, 1) && be_isstring(vm, 2)) {
const char * method_name = be_tostring(vm, 2); // the method we are looking for
while (be_isinstance(vm, 1)) {
const char * class_name = be_classname(vm, 1);
// berry_log_C("lvx_member looking for method '%s' of class '%s'", method_name, class_name);
// look for class descriptor
int32_t class_idx = bin_search(class_name, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
if (class_idx < 0) {
// class not found, abort
// berry_log_C("lvx_member class not found");
be_return_nil(vm);
}
const lvbe_call_c_t * methods_calls = lv_classes[class_idx].func_table;
size_t methods_size = lv_classes[class_idx].size;
int32_t method_idx = bin_search(method_name, methods_calls, sizeof(lvbe_call_c_t), methods_size);
if (method_idx >= 0) {
// method found
// berry_log_C("lvx_member method found");
const lvbe_call_c_t * method = &methods_calls[method_idx];
// push native closure
be_pushntvclosure(vm, &lvx_call_c, 3); // 3 upvals
be_pushcomptr(vm, method->func);
be_setupval(vm, -2, 0);
be_pop(vm, 1);
be_pushstring(vm, method->return_type);
be_setupval(vm, -2, 1);
be_pop(vm, 1);
be_pushstring(vm, method->arg_type);
be_setupval(vm, -2, 2);
be_pop(vm, 1);
// all good
be_return(vm);
}
// get super if any, or nil if none
be_getsuper(vm, 1);
be_moveto(vm, -1, 1);
be_pop(vm, 1);
}
// berry_log_C("lvx_member method not found");
be_return_nil(vm);
}
be_raise(vm, kTypeError, nullptr);
}
int be_call_c_func(bvm *vm, void * func, const char * return_type, const char * arg_type) {
int32_t p[5] = {0,0,0,0,0};
int32_t argc = be_top(vm); // Get the number of arguments
// check if we call a constructor
if (return_type && return_type[0] == '+') {
return_type++; // skip the leading '+'
return lvx_init_2(vm, func, return_type);
}
fn_any_callable f = (fn_any_callable) func;
be_check_arg_type(vm, argc, arg_type, p);
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func(%p) - %p,%p,%p,%p,%p - %s", f, p[0], p[1], p[2], p[3], p[4], return_type);
int32_t ret = (*f)(p[0], p[1], p[2], p[3], p[4]);
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func, ret = %p", ret);
if ((return_type == nullptr) || (strlen(return_type) == 0)) { be_return_nil(vm); } // does not return
else if (strlen(return_type) == 1) {
switch (return_type[0]) {
case '.': // fallback next
case 'i': be_pushint(vm, ret); break;
case 'b': be_pushbool(vm, ret); break;
case 's': be_pushstring(vm, (const char*) ret); break;
default: be_raise(vm, "internal_error", "Unsupported return type"); break;
}
be_return(vm);
} else { // class name
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func, create_obj", ret);
be_getglobal(vm, return_type); // stack = class
be_pushcomptr(vm, (void*) -1); // stack = class, -1
be_pushcomptr(vm, (void*) ret); // stack = class, -1, ptr
be_call(vm, 2); // instanciate with 2 arguments, stack = instance, -1, ptr
be_pop(vm, 2); // stack = instance
be_return(vm);
}
be_return(vm);
} else { // class name
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func, create_obj", ret);
be_getglobal(vm, return_type); // stack = class
be_pushcomptr(vm, (void*) -1); // stack = class, -1
be_pushcomptr(vm, (void*) ret); // stack = class, -1, ptr
be_call(vm, 2); // instanciate with 2 arguments, stack = instance, -1, ptr
be_pop(vm, 2); // stack = instance
be_return(vm);
}
}
@ -631,6 +774,68 @@ extern "C" {
lv_img_set_src(img, &tasmota_logo_64_truecolor);
}
/*********************************************************************************************\
* LVGL top level virtual members
*
* Responds to virtual constants
\*********************************************************************************************/
typedef struct lvbe_constant_t {
const char * name;
int32_t value;
} lvbe_constant_t;
extern const lvbe_call_c_t lv_func[];
extern const size_t lv_func_size;
extern const lvbe_constant_t lv0_constants[];
extern const size_t lv0_constants_size;
int lv0_member(bvm *vm);
int lv0_member(bvm *vm) {
int32_t argc = be_top(vm); // Get the number of arguments
if (argc == 1 && be_isstring(vm, 1)) {
const char * needle = be_tostring(vm, 1);
int32_t constant_idx = bin_search(needle, &lv0_constants[0].name, sizeof(lv0_constants[0]), lv0_constants_size);
if (constant_idx >= 0) {
// we did have a match, low == high
be_pushint(vm, lv0_constants[constant_idx].value);
be_return(vm);
} else {
// search for a method with this name
int32_t method_idx = bin_search(needle, &lv_func[0].name, sizeof(lv_func[0]), lv_func_size);
if (method_idx >= 0) {
const lvbe_call_c_t * method = &lv_func[method_idx];
// push native closure
be_pushntvclosure(vm, &lvx_call_c, 3); // 3 upvals
be_pushcomptr(vm, method->func);
be_setupval(vm, -2, 0);
be_pop(vm, 1);
be_pushstring(vm, method->return_type);
be_setupval(vm, -2, 1);
be_pop(vm, 1);
be_pushstring(vm, method->arg_type);
be_setupval(vm, -2, 2);
be_pop(vm, 1);
// all good
be_return(vm);
} else {
be_return_nil(vm);
}
}
}
be_raise(vm, kTypeError, nullptr);
}
/*********************************************************************************************\
* LVGL Start
*
@ -739,23 +944,6 @@ extern "C" {
return more_to_report;
}
/*********************************************************************************************\
* Methods specific to Tasmota LVGL
\*********************************************************************************************/
// lv.scr_act() -> lv_obj() instance
int lv0_scr_act(bvm *vm) { return lv0_lvobj__void_call(vm, &lv_scr_act); }
int lv0_layer_top(bvm *vm) { return lv0_lvobj__void_call(vm, &lv_layer_top); }
int lv0_layer_sys(bvm *vm) { return lv0_lvobj__void_call(vm, &lv_layer_sys); }
int lv0_get_hor_res(bvm *vm) {
be_pushint(vm, lv_disp_get_hor_res(lv_disp_get_default()));
be_return(vm);
}
int lv0_get_ver_res(bvm *vm) {
be_pushint(vm, lv_disp_get_ver_res(lv_disp_get_default()));
be_return(vm);
}
/*********************************************************************************************\
* Support for lv_indev and objects that don't need creator
\*********************************************************************************************/
@ -790,32 +978,6 @@ extern "C" {
be_return_nil(vm);
}
// called programmatically
int lvx_init_2(bvm *vm, void * func, const char * return_type, const char * arg_type = nullptr);
int lvx_init_2(bvm *vm, void * func, const char * return_type, const char * arg_type) {
int argc = be_top(vm);
lv_obj_t * obj1 = nullptr;
lv_obj_t * obj2 = nullptr;
if (argc > 1) {
obj1 = (lv_obj_t*) be_convert_single_elt(vm, 2);
}
if (argc > 2) {
obj2 = (lv_obj_t*) be_convert_single_elt(vm, 3);
}
// AddLog(LOG_LEVEL_INFO, "argc %d lv_obj %p", argc, obj);
fn_any_callable f = (fn_any_callable) func;
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func(%p) - %p,%p,%p,%p,%p", f, p[0], p[1], p[2], p[3], p[4]);
lv_obj_t * obj;
if ((int32_t)obj1 == -1) { // special semantics of first ptr is -1, then just encapsulate
obj = obj2;
} else { // otherwise call the LVGL creator
obj = (lv_obj_t*) (*f)((int32_t)obj1, (int32_t)obj2, 0, 0, 0);
}
lv_init_set_member(vm, 1, obj);
be_return_nil(vm);
}
int lvx_tostring(bvm *vm) {
lv_obj_t * obj = (lv_obj_t*) lv_get_arg(vm, 1);
const char * classname = be_classname(vm, 1);

22
tasmota/xdrv_54_lvgl.ino
View File

@ -32,6 +32,10 @@
#include "Adafruit_LvGL_Glue.h"
#ifdef USE_LVGL_PNG_DECODER
#include "lv_png.h"
#endif // USE_LVGL_PNG_DECODER
Adafruit_LvGL_Glue * glue;
// **************************************************
@ -219,7 +223,6 @@ static lv_fs_res_t lvbe_fs_open(lv_fs_drv_t * drv, void * file_p, const char * p
// AddLog(LOG_LEVEL_INFO, "LVG: F=%*_H", sizeof(f), &f);
if (f) {
File * f_ptr = new File(f); // copy to dynamic object
*f_ptr = f; // TODO is this necessary?
*((File**)file_p) = f_ptr;
return LV_FS_RES_OK;
} else {
@ -339,6 +342,14 @@ extern "C" {
void lvbe_free(void *ptr) {
free(ptr);
}
#ifdef USE_LVGL_PNG_DECODER
// for PNG decoder, use same allocators as LVGL
void* lodepng_malloc(size_t size) { return lvbe_malloc(size); }
void* lodepng_realloc(void* ptr, size_t new_size) { return lvbe_realloc(ptr, new_size); }
void lodepng_free(void* ptr) { lvbe_free(ptr); }
#endif // USE_LVGL_PNG_DECODER
}
/************************************************************
@ -428,8 +439,15 @@ void start_lvgl(const char * uconfig) {
// initialize the FreeType renderer
lv_freetype_init(USE_LVGL_FREETYPE_MAX_FACES,
USE_LVGL_FREETYPE_MAX_SIZES,
USE_LVGL_FREETYPE_MAX_BYTES);
psramFound() ? USE_LVGL_FREETYPE_MAX_BYTES_PSRAM : USE_LVGL_FREETYPE_MAX_BYTES);
#endif
#ifdef USE_LVGL_PNG_DECODER
lv_png_init();
#endif // USE_LVGL_PNG_DECODER
if (psramFound()) {
lv_img_cache_set_size(LV_IMG_CACHE_DEF_SIZE_PSRAM);
}
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_LVGL "LVGL initialized"));
}

222
tools/lv_berry/convert.py
View File

@ -33,8 +33,8 @@ return_types = {
"int16_t": "i",
"uint32_t": "i",
"int32_t": "i",
"void *": "i",
"const void *": "i",
"void *": ".",
"const void *": ".",
"char *": "s",
"const char *": "s",
"lv_obj_user_data_t": "i",
@ -202,17 +202,26 @@ with open(lv_module_file) as f:
lv_module.append( [ None, l_raw ] ) # if key in None then add comment line
l_raw = re.sub('//.*$', '', l_raw) # remove trailing comments
l_raw = re.sub('\s+', '', l_raw) # remove all spaces
l_raw = re.sub(',.*$', '', l_raw) # remove comma and anything after it
if (len(l_raw) == 0): continue
k_v = l_raw.split("=")
if len(k_v) != 2:
if len(k_v) > 2:
print(f"Error: cannot match {l_raw}")
continue
# extract the key name
k = k_v[0]
if k.startswith("_"):
continue # skip any label starting with '_'
k = re.sub('^LV_', '', k) # remove remove any LV_ prefix
v = k_v[1]
if k is None or v is None: continue
v_num = try_int(eval(v))
if len(k_v) == 2: # value is included
v = k_v[1]
if k is None or v is None: continue
v_num = try_int(eval(v))
else: # no value, we use the C value instead
v_num = None
v = None
if not k.isidentifier():
print(f"Error: {k} is not an identifier")
@ -221,7 +230,7 @@ with open(lv_module_file) as f:
if v_num is not None:
lv_module.append( [k, v_num] )
else:
lv_modile.append( [k, v] ) # keep as string
lv_module.append( [k, v] ) # keep as string or None
# recursively try to match value
# TODO
@ -262,8 +271,56 @@ print("""
#ifdef __cplusplus
extern "C" {
#endif
""")
for subtype, flv in lv.items():
print(f"/* `lv_{subtype}` methods */")
if subtype in lv_widgets:
print(f"#if BE_LV_WIDGET_{subtype.upper()}")
print(f"const lvbe_call_c_t lv_{subtype}_func[] = {{")
func_out = {} # used to sort output
for f in flv:
c_func_name = f[0]
c_ret_type = f[1]
c_argc = f[2]
if c_argc is not None: c_argc = "\"" + c_argc + "\""
orig_func_name = f[3]
be_name = f[4]
if c_func_name.endswith("_create"):
c_ret_type = f"+lv_{subtype}"
func_out[be_name] = f" {{ \"{be_name}\", (void*) &{orig_func_name}, \"{c_ret_type}\", { c_argc if c_argc else 'nullptr'} }},"
for be_name in sorted(func_out):
print(func_out[be_name])
print(f"}};")
if subtype in lv_widgets:
print(f"#endif // BE_LV_WIDGET_{subtype.upper()}")
print(f"")
# print the global map of classes
print(f"""
// map of clases
const lvbe_call_c_classes_t lv_classes[] = {{""")
for subtype in sorted(lv):
# for subtype, flv in lv.items():
if subtype in lv_widgets:
print(f"#if BE_LV_WIDGET_{subtype.upper()}")
print(f" {{ \"lv_{subtype}\", lv_{subtype}_func, sizeof(lv_{subtype}_func) / sizeof(lv_{subtype}_func[0]) }},")
if subtype in lv_widgets:
print(f"#endif // BE_LV_WIDGET_{subtype.upper()}")
print(f"""}};
const size_t lv_classes_size = sizeof(lv_classes) / sizeof(lv_classes[0]);
""")
# previous generation calls
# keep only create
for subtype, flv in lv.items():
print(f" /* `lv_{subtype}` methods */")
for f in flv:
@ -272,11 +329,13 @@ for subtype, flv in lv.items():
c_argc = f[2]
if c_argc is not None: c_argc = "\"" + c_argc + "\""
orig_func_name = f[3]
#print(f" int {c_func_name}(bvm *vm) \{ return (vm, be_call_c_func(void*) &")
if c_func_name.endswith("_create"):
print(f" int {c_func_name}(bvm *vm) {{ return lvx_init_2(vm, (void*) &{orig_func_name}, \"lv_{subtype}\", { c_argc if c_argc else 'nullptr'}); }}")
else:
c_ret_type = f"+lv_{subtype}"
if subtype in lv_widgets:
print(f"#if BE_LV_WIDGET_{subtype.upper()}")
print(f" int {c_func_name}(bvm *vm) {{ return be_call_c_func(vm, (void*) &{orig_func_name}, \"{c_ret_type}\", { c_argc if c_argc else 'nullptr'}); }}")
if subtype in lv_widgets:
print(f"#endif // BE_LV_WIDGET_{subtype.upper()}")
print()
print()
@ -316,24 +375,15 @@ print("""
#ifdef USE_LVGL
#include "lvgl.h"
extern int lv0_start(bvm *vm);
#include "be_lvgl.h"
extern int lv0_init(bvm *vm);
extern int lv0_register_button_encoder(bvm *vm); // add buttons with encoder logic
extern int lv0_scr_act(bvm *vm);
extern int lv0_layer_top(bvm *vm);
extern int lv0_layer_sys(bvm *vm);
extern int lv0_get_hor_res(bvm *vm);
extern int lv0_get_ver_res(bvm *vm);
extern int lv0_screenshot(bvm *vm);
extern int lco_init(bvm *vm);
extern int lco_tostring(bvm *vm);
extern int lvx_init_2(bvm *vm); // generic function
extern int lvx_member(bvm *vm);
extern int lvx_tostring(bvm *vm); // generic function
extern int lvs_init(bvm *vm);
@ -379,13 +429,14 @@ for subtype, flv in lv.items():
else:
print(f" {{ \"init\", lv0_init }},")
print(f" {{ \"tostring\", lvx_tostring }},")
print(f" {{ \"member\", lvx_member }},")
print()
for f in flv:
# for f in flv:
c_func_name = f[0]
be_name = f[4]
print(f" {{ \"{be_name}\", {c_func_name} }},")
# c_func_name = f[0]
# be_name = f[4]
# print(f" {{ \"{be_name}\", {c_func_name} }},")
print()
print(f" // {{ NULL, (bntvfunc) BE_CLOSURE }}, /* mark section for berry closures */")
@ -424,11 +475,13 @@ for subtype, flv in lv.items():
else:
print(f" init, func(lv0_init)")
print(f" tostring, func(lvx_tostring)")
print(f" member, func(lvx_member)")
print()
for f in flv:
c_func_name = f[0]
be_name = f[4]
print(f" {be_name}, func({c_func_name})")
# for f in flv:
# c_func_name = f[0]
# be_name = f[4]
# print(f" {be_name}, func({c_func_name})")
print(f"}}")
print(f"@const_object_info_end */")
@ -453,6 +506,9 @@ print("""/********************************************************************
#ifdef USE_LVGL
#include "lvgl.h"
#include "be_lvgl.h"
extern int lv0_member(bvm *vm); // resolve virtual members
extern int lv0_start(bvm *vm);
@ -463,12 +519,61 @@ extern int lv0_load_seg7_font(bvm *vm);
extern int lv0_load_font(bvm *vm);
extern int lv0_load_freetype_font(bvm *vm);
extern int lv0_scr_act(bvm *vm);
extern int lv0_layer_top(bvm *vm);
extern int lv0_layer_sys(bvm *vm);
extern int lv0_get_hor_res(bvm *vm);
extern int lv0_get_ver_res(bvm *vm);
extern int lv0_screenshot(bvm *vm);
static int lv_get_hor_res(void) {
return lv_disp_get_hor_res(lv_disp_get_default());
}
static int lv_get_ver_res(bvm *vm) {
return lv_disp_get_ver_res(lv_disp_get_default());
}
/* `lv` methods */
const lvbe_call_c_t lv_func[] = {
// resolution
{ "get_hor_res", (void*) &lv_get_hor_res, "i", "" },
{ "get_ver_res", (void*) &lv_get_ver_res, "i", "" },
// layers
{ "layer_sys", (void*) &lv_layer_sys, "lv_obj", "" },
{ "layer_top", (void*) &lv_layer_top, "lv_obj", "" },
// screens
{ "scr_act", (void*) &lv_scr_act, "lv_obj", "" },
{ "scr_load", (void*) &lv_scr_load, "", "(lv_obj)" },
{ "scr_load_anim", (void*) &lv_scr_load_anim, "", "(lv_obj)iiib" },
};
const size_t lv_func_size = sizeof(lv_func) / sizeof(lv_func[0]);
""")
print("""
typedef struct lvbe_constant_t {
const char * name;
int32_t value;
} lvbe_constant_t;
const lvbe_constant_t lv0_constants[] = {
""")
lv_module2 = {}
for k_v in lv_module:
(k,v) = k_v
if k is not None:
lv_module2[k] = v
for k in sorted(lv_module2):
v = lv_module2[k]
if v is not None:
print(f" {{ \"{k}\", {v} }},")
else:
print(f" {{ \"{k}\", LV_{k} }},")
print("""
};
const size_t lv0_constants_size = sizeof(lv0_constants)/sizeof(lv0_constants[0]);
""")
for f in lv0:
@ -545,13 +650,6 @@ be_native_module_attr_table(lvgl) {
be_native_module_str("SYMBOL_BULLET", "\\xE2\\x80\\xA2"),
// connection type
be_native_module_int("SPI", 0),
be_native_module_int("I2C", 1),
// connection sub_type
be_native_module_int("HSPI", 0),
be_native_module_int("VSPI", 1),
be_native_module_int("SSPI", 2),
""")
print("/* `lvgl` module functions */")
@ -567,16 +665,17 @@ print()
# print()
for k_v in lv_module:
(k,v) = k_v
if k is None:
print(v) # comment line
continue
# for k_v in lv_module:
# (k,v) = k_v
# if k is None:
# print(v) # comment line
# continue
print(f" be_native_module_int(\"{k}\", {v}),")
# print(f" be_native_module_int(\"{k}\", {v}),")
print("""
be_native_module_function("member", lv0_member),
be_native_module_function("start", lv0_start),
be_native_module_function("register_button_encoder", lv0_register_button_encoder),
@ -586,13 +685,6 @@ print("""
be_native_module_function("load_font", lv0_load_font),
be_native_module_function("load_freetype_font", lv0_load_freetype_font),
// screen and layers
be_native_module_function("scr_act", lv0_scr_act),
be_native_module_function("layer_top", lv0_layer_top),
be_native_module_function("layer_sys", lv0_layer_sys),
be_native_module_function("get_hor_res", lv0_get_hor_res),
be_native_module_function("get_ver_res", lv0_get_ver_res),
be_native_module_function("screenshot", lv0_screenshot),
""")
@ -735,23 +827,18 @@ module lvgl (scope: global) {
SYMBOL_DUMMY, str(&be_local_const_str_SYMBOL_DUMMY)
SYMBOL_BULLET, str(&be_local_const_str_SYMBOL_BULLET)
SPI, int(0)
I2C, int(1)
HSPI, int(0)
VSPI, int(1)
SSPI, int(2)
""")
for k_v in lv_module:
(k,v) = k_v
if k is None:
continue
# for k_v in lv_module:
# (k,v) = k_v
# if k is None:
# continue
print(f" {k}, int({v})")
# print(f" {k}, int({v})")
print("""
member, func(lv0_member)
start, func(lv0_start)
register_button_encoder, func(lv0_register_button_encoder)
@ -761,11 +848,6 @@ print("""
load_font, func(lv0_load_font)
load_freetype_font, func(lv0_load_freetype_font)
scr_act, func(lv0_scr_act)
layer_top, func(lv0_layer_top)
layer_sys, func(lv0_layer_sys)
get_hor_res, func(lv0_get_hor_res)
get_ver_res, func(lv0_get_ver_res)
screenshot, func(lv0_screenshot)
""")

908
tools/lv_berry/lv_module.h
View File

File diff suppressed because it is too large Load Diff

BIN
tools/mqtt-file/Config_demo_9.4.0.4.dmp
View File

Binary file not shown.

111
tools/mqtt-file/download-settings.py
View File

@ -42,16 +42,20 @@ import json
broker = "domus1" # MQTT broker ip address or name
broker_port = 1883 # MQTT broker port
mypassword = "" # Tasmota MQTT password
mytopic = "demo" # Tasmota MQTT topic
myfiletype = 2 # Tasmota Settings file type
# **** End of User Configuration Section
use_base64 = True
# Derive fulltopic from broker LWT message
mypublish = "cmnd/"+mytopic+"/filedownload"
mysubscribe = "stat/"+mytopic+"/FILEDOWNLOAD" # Case sensitive
Ack_flag = False
Err_flag = False
file_name = ""
file_id = 0
@ -62,7 +66,7 @@ file_md5 = ""
# The callback for when mysubscribe message is received
def on_message(client, userdata, msg):
global Ack_flag
global Run_flag
global Err_flag
global file_name
global file_id
global file_type
@ -73,56 +77,80 @@ def on_message(client, userdata, msg):
base64_data = ""
rcv_id = 0
# print("Received message =",str(msg.payload.decode("utf-8")))
# try:
# print("Received message =",str(msg.payload.decode("utf-8")))
# except:
# print("Received message = binary data")
root = json.loads(msg.payload.decode("utf-8"))
if "File" in root: file_name = root["File"]
if "Id" in root: rcv_id = root["Id"]
if "Type" in root: file_type = root["Type"]
if "Size" in root: file_size = root["Size"]
if "Data" in root: base64_data = root["Data"]
if "Md5" in root: file_md5 = root["Md5"]
try:
root = json.loads(msg.payload.decode("utf-8"))
if root:
if "FileDownload" in root:
rcv_code = root["FileDownload"]
if "Aborted" in rcv_code:
print("Error: Aborted")
Err_flag = True
return
if "Started" in rcv_code:
return
if "Error" in rcv_code:
print("Error: "+rcv_code)
Err_flag = True
return
if "Command" in root:
rcv_code = root["Command"]
if rcv_code == "Error":
print("Error: Command error")
Err_flag = True
return
if "File" in root: file_name = root["File"]
if "Id" in root: rcv_id = root["Id"]
if "Type" in root: file_type = root["Type"]
if "Size" in root: file_size = root["Size"]
if "Data" in root: base64_data = root["Data"]
if "Md5" in root: file_md5 = root["Md5"]
except:
pass
if file_id == 0 and rcv_id > 0 and file_size > 0 and file_type > 0 and file_name:
file_id = rcv_id
fi = open(file_name,"wb")
fi.close()
else:
if file_id > 0 and file_id != rcv_id:
Run_flag = False
if use_base64 and file_id > 0 and file_id != rcv_id:
Err_flag = True
return
if file_md5 == "" and base64_data:
base64_decoded_data = base64_data.encode('utf-8')
chunk = base64.decodebytes(base64_decoded_data)
in_hash_md5.update(chunk) # Update hash
fi = open(file_name,"ab")
fi.write(chunk)
fi.close()
if file_md5 == "" and file_name:
if use_base64 and base64_data:
base64_decoded_data = base64_data.encode('utf-8')
chunk = base64.decodebytes(base64_decoded_data)
in_hash_md5.update(chunk) # Update hash
fi = open(file_name,"ab")
fi.write(chunk)
fi.close()
if use_base64 == False and 0 == rcv_id:
chunk = msg.payload
in_hash_md5.update(chunk) # Update hash
fi = open(file_name,"ab")
fi.write(chunk)
fi.close()
if file_md5 != "":
md5_hash = in_hash_md5.hexdigest()
if md5_hash != file_md5:
print("Error: MD5 mismatch")
Run_flag = False
Err_flag = True
Ack_flag = False
def wait_for_ack():
global Ack_flag
global Run_flag
if Run_flag == False:
print("Error: Transmission")
return True
timeout = 100
while Ack_flag and timeout > 0:
while Ack_flag and Err_flag == False and timeout > 0:
time.sleep(0.01)
timeout = timeout -1
if Ack_flag:
if 0 == timeout:
print("Error: Timeout")
return Ack_flag
@ -138,35 +166,32 @@ print("Downloading file from "+mytopic+" ...")
in_hash_md5 = hashlib.md5()
Err_flag = False
client.publish(mypublish, str(myfiletype))
if use_base64:
client.publish(mypublish, "{\"Password\":\""+mypassword+"\",\"Type\":"+str(myfiletype)+"}")
else:
client.publish(mypublish, "{\"Password\":\""+mypassword+"\",\"Type\":"+str(myfiletype)+",\"Binary\":1}")
Ack_flag = True
Run_flag = True
while Run_flag:
if wait_for_ack(): # We use Ack here
Err_flag = True
client.publish(mypublish, "0") # Abort any failed download
Run_flag = False
else:
if file_md5 == "":
if file_md5 == "": # Request chunk
client.publish(mypublish, "?")
Ack_flag = True
else:
Run_flag = False
if Err_flag:
client.publish(mypublish, "0") # Abort any failed download
if Err_flag == False:
file_type_name = "Data"
if file_type == 2:
file_type_name = "Settings"
print("Downloaded "+file_type_name+" saved as "+file_name)
time_taken = time.time() - time_start
file_type_name = " Data"
if file_type == 2:
file_type_name = " Settings"
print("Downloaded"+file_type_name+" saved as "+file_name)
print("Done in "+str("%.2f"%time_taken)+" seconds")
client.disconnect() # Disconnect

62
tools/mqtt-file/upload-ota.py
View File

@ -50,19 +50,22 @@ myfiletype = 1 # Tasmota firmware file type
# **** End of User Configuration Section
use_base64 = False
# Derive fulltopic from broker LWT message
mypublish = "cmnd/"+mytopic+"/fileupload"
mysubscribe = "stat/"+mytopic+"/FILEUPLOAD" # Case sensitive
Ack_flag = False
Err_flag = False
use_base64 = False
file_id = 114 # Even id between 2 and 254
file_chunk_size = 700 # Default Tasmota MQTT max message size
# The callback for when mysubscribe message is received
def on_message(client, userdata, msg):
global Ack_flag
global Err_flag
global file_chunk_size
rcv_code = ""
@ -71,31 +74,43 @@ def on_message(client, userdata, msg):
# print("Received message =",str(msg.payload.decode("utf-8")))
root = json.loads(msg.payload.decode("utf-8"))
if "FileUpload" in root: rcv_code = root["FileUpload"]
if "Error" in rcv_code:
print("Error: "+rcv_code)
return
if "Command" in root: rcv_code = root["Command"]
if rcv_code == "Error":
print("Error: Command error")
return
if "Id" in root: rcv_id = root["Id"]
if rcv_id == file_id:
if "MaxSize" in root: file_chunk_size = root["MaxSize"]
if "FileUpload" in root:
rcv_code = root["FileUpload"]
if "Aborted" in rcv_code:
print("Error: Aborted")
Err_flag = True
return
if "MD5 mismatch" in rcv_code:
print("Error: MD5 mismatch")
Err_flag = True
return
if "Started" in rcv_code:
return
if "Error" in rcv_code:
print("Error: "+rcv_code)
Err_flag = True
return
if "Command" in root:
rcv_code = root["Command"]
if rcv_code == "Error":
print("Error: Command error")
Err_flag = True
return
if "Id" in root:
rcv_id = root["Id"]
if rcv_id == file_id:
if "MaxSize" in root: file_chunk_size = root["MaxSize"]
Ack_flag = False
def wait_for_ack():
global Ack_flag
timeout = 100
while Ack_flag and timeout > 0:
while Ack_flag and Err_flag == False and timeout > 0:
time.sleep(0.01)
timeout = timeout -1
if Ack_flag:
print("Error: Ack timeout")
if 0 == timeout:
print("Error: Timeout")
return Ack_flag
@ -112,6 +127,7 @@ fo = open(myfile,"rb")
fo.seek(0, 2) # os.SEEK_END
file_size = fo.tell()
fo.seek(0, 0) # os.SEEK_SET
file_pos = 0
client.publish(mypublish, "{\"Password\":\""+mypassword+"\",\"File\":\""+myfile+"\",\"Id\":"+str("%3d"%file_id)+",\"Type\":"+str(myfiletype)+",\"Size\":"+str(file_size)+"}")
Ack_flag = True
@ -120,13 +136,14 @@ out_hash_md5 = hashlib.md5()
Run_flag = True
while Run_flag:
if wait_for_ack(): # We use Ack here
if wait_for_ack(): # We use Ack here
client.publish(mypublish, "0") # Abort any failed upload
Run_flag = False
else:
chunk = fo.read(file_chunk_size)
if chunk:
out_hash_md5.update(chunk) # Update hash
out_hash_md5.update(chunk) # Update hash
if use_base64:
base64_encoded_data = base64.b64encode(chunk)
base64_data = base64_encoded_data.decode('utf-8')
@ -134,6 +151,11 @@ while Run_flag:
client.publish(mypublish, "{\"Id\":"+str("%3d"%file_id)+",\"Data\":\""+base64_data+"\"}")
else:
client.publish(mypublish+"201", chunk)
file_pos = file_pos + file_chunk_size
if file_pos % 102400 < file_chunk_size:
progress = round((file_pos / 10240)) * 10
print("Progress "+str("%d"%progress)+" kB")
Ack_flag = True
else:

56
tools/mqtt-file/upload-settings.py
View File

@ -44,24 +44,27 @@ broker_port = 1883 # MQTT broker port
mypassword = "" # Tasmota MQTT password
mytopic = "demo" # Tasmota MQTT topic
myfile = "Config_demo_9.4.0.3.dmp" # Tasmota Settings file name
myfile = "Config_demo_9.4.0.4.dmp" # Tasmota Settings file name
myfiletype = 2 # Tasmota Settings file type
# **** End of User Configuration Section
use_base64 = True
# Derive fulltopic from broker LWT message
mypublish = "cmnd/"+mytopic+"/fileupload"
mysubscribe = "stat/"+mytopic+"/FILEUPLOAD" # Case sensitive
Ack_flag = False
Err_flag = False
use_base64 = True
file_id = 116 # Even id between 2 and 254
file_chunk_size = 700 # Default Tasmota MQTT max message size
# The callback for when mysubscribe message is received
def on_message(client, userdata, msg):
global Ack_flag
global Err_flag
global file_chunk_size
rcv_code = ""
@ -70,31 +73,43 @@ def on_message(client, userdata, msg):
# print("Received message =",str(msg.payload.decode("utf-8")))
root = json.loads(msg.payload.decode("utf-8"))
if "FileUpload" in root: rcv_code = root["FileUpload"]
if "Error" in rcv_code:
print("Error: "+rcv_code)
return
if "Command" in root: rcv_code = root["Command"]
if rcv_code == "Error":
print("Error: Command error")
return
if "Id" in root: rcv_id = root["Id"]
if rcv_id == file_id:
if "MaxSize" in root: file_chunk_size = root["MaxSize"]
if "FileUpload" in root:
rcv_code = root["FileUpload"]
if "Aborted" in rcv_code:
print("Error: Aborted")
Err_flag = True
return
if "MD5 mismatch" in rcv_code:
print("Error: MD5 mismatch")
Err_flag = True
return
if "Started" in rcv_code:
return
if "Error" in rcv_code:
print("Error: "+rcv_code)
Err_flag = True
return
if "Command" in root:
rcv_code = root["Command"]
if rcv_code == "Error":
print("Error: Command error")
Err_flag = True
return
if "Id" in root:
rcv_id = root["Id"]
if rcv_id == file_id:
if "MaxSize" in root: file_chunk_size = root["MaxSize"]
Ack_flag = False
def wait_for_ack():
global Ack_flag
timeout = 100
while Ack_flag and timeout > 0:
while Ack_flag and Err_flag == False and timeout > 0:
time.sleep(0.01)
timeout = timeout -1
if Ack_flag:
print("Error: Ack timeout")
if 0 == timeout:
print("Error: Timeout")
return Ack_flag
@ -119,7 +134,8 @@ out_hash_md5 = hashlib.md5()
Run_flag = True
while Run_flag:
if wait_for_ack(): # We use Ack here
if wait_for_ack(): # We use Ack here
client.publish(mypublish, "0") # Abort any failed upload
Run_flag = False
else: