import re import sys lv_widgets_file = "lv_widgets.h" lv_module_file = "lv_module.h" out_prefix = "../../tasmota/lvgl_berry/" lvgl_prefix = "../../lib/libesp32/Berry/default/" lvgl_prefix = "../../lib/libesp32/Berry/default/" be_lv_defines = "be_lv_defines.h" be_lv_c_mapping = "be_lv_c_mapping.h" be_lv_widgets_libs = "be_lvgl_widgets_lib.c" be_lv_lvgl_module = "be_lv_lvgl_module.c" # detect a function definition all # Ex: 'void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent);' # Group 1: 'void' # Group 2: 'lv_obj_set_parent' # Group 3: 'lv_obj_t * obj, lv_obj_t * parent' parse_func_def = re.compile("(.*?)\s(\w+)\((.*?)\)") # parse call argument type # Ex: 'const lv_obj_t * parent' -> 'const ', 'lv_obj_t', ' * ', 'parent' # Ex: 'bool auto_fit' -> '', 'bool', ' ', 'auto_fit' parse_arg = re.compile("(\w+\s+)?(\w+)([\*\s]+)(\w+)") return_types = { "void": "", "bool": "b", "uint8_t": "i", "uint16_t": "i", "int16_t": "i", "uint32_t": "i", "int32_t": "i", "void *": ".", "const void *": ".", "char *": "s", "const char *": "s", "lv_obj_user_data_t": "i", "lv_objmask_mask_t *": ".", "lv_coord_t": "i", "lv_res_t": "i", "lv_style_int_t": "i", "lv_opa_t": "i", "lv_drag_dir_t": "i", "lv_bidi_dir_t": "i", "lv_state_t": "i", "lv_arc_type_t":"i", "lv_chart_axis_t":"i", "lv_bar_type_t":"i", "lv_btn_state_t":"i", "lv_point_t":"i", "lv_chart_type_t":"i", "lv_fit_t":"i", "lv_cpicker_color_mode_t":"i", "lv_dropdown_dir_t":"i", "lv_layout_t":"i", "lv_color_hsv_t":"i", "lv_label_long_mode_t": "i", "lv_label_align_t": "i", "lv_scrollbar_mode_t": "i", "lv_spinbox_part_t": "i", "lv_spinner_style_t": "i", "lv_anim_value_t": "i", "lv_switch_part_t": "i", "lv_label_align_t": "i", "lv_tabview_btns_pos_t": "i", "lv_textarea_style_t": "i", "lv_slider_type_t": "i", "lv_spinner_type_t": "i", "lv_spinner_dir_t": "i", "lv_blend_mode_t": "i", "lv_grad_dir_t": "i", "lv_border_side_t": "i", "lv_align_t": "i", "lv_keyboard_mode_t": "i", "lv_indev_type_t": "i", "lv_event_t": "i", "lv_signal_t": "i", "lv_img_cf_t": "i", "lv_draw_mask_line_side_t": "i", # "lv_signal_cb_t": "c", # "lv_design_cb_t": "c", # "lv_event_cb_t": "c", # "lv_group_focus_cb_t": "c", "lv_obj_t *": "lv_obj", "lv_color_t": "lv_color", "lv_style_t *": "lv_style", "lv_group_t *": "lv_group", #"lv_disp_t*": "lv_disp", #"lv_style_list_t*": "", # callbacks "lv_group_focus_cb_t": "lv_group_focus_cb", "lv_event_cb_t": "lv_event_cb", "lv_signal_cb_t": "lv_signal_cb", "lv_design_cb_t": "lv_design_cb", "lv_gauge_format_cb_t": "lv_gauge_format_cb", } lv = {} lvs = [] # special case for case for lv_style lv0 = [] # function in lvlg module lv_module = [] lv_cb_types = ['lv_group_focus_cb', 'lv_event_cb', 'lv_signal_cb', 'lv_design_cb', 'lv_gauge_format_cb'] # list of callback types that will need each a separate C callback lv_widgets = ['arc', 'bar', 'btn', 'btnmatrix', 'calendar', 'canvas', 'chart', 'checkbox', 'cont', 'cpicker', 'dropdown', 'gauge', 'img', 'imgbtn', 'keyboard', 'label', 'led', 'line', 'linemeter', 'list', 'msgbox', 'objmask', 'templ', 'page', 'roller', 'slider', 'spinbox', 'spinner', 'switch', 'table', 'tabview', 'textarea', 'tileview', 'win'] lv_prefix = ['obj', 'group', 'style', 'indev', ] + lv_widgets def try_int(s): try: v = int(s) return v except ValueError: return None # convert a C return type to the string representation for the Berry parser # using return_types def c_convert_ret_type(c_ret): return return_types.get(c_ret, "") # parse widgets files containing most function calls with open(lv_widgets_file) as f: for l_raw in f: l_raw = re.sub('//.*$', '', l_raw) # remove trailing comments l_raw = re.sub('LV_ATTRIBUTE_FAST_MEM ', '', l_raw) # remove LV_ATTRIBUTE_FAST_MEM marker l_raw = re.sub('\s+', ' ', l_raw) # replace any multi-space with a single space l_raw = l_raw.strip(" \t\n\r") # remove leading or trailing spaces l_raw = re.sub('static ', '', l_raw) l_raw = re.sub('inline ', '', l_raw) if (len(l_raw) == 0): continue g = parse_func_def.search(l_raw) if g: # if match, we parse the line # Ex: 'void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent);' ret_type = g.group(1) # return type of the function # Ex: ret_type -> 'void' ret_type_without_t = re.sub(r"_t$", "", ret_type) if ret_type in return_types: # convert return type c_ret = c_convert_ret_type(ret_type) elif ret_type_without_t in lv_cb_types: c_ret = "c" # general callback, if not already captured by explicit type else: print(f" // Skipping unsupported return type: {ret_type}") continue # convert arguments c_args = "" args_raw = [ x.strip(" \t\n\r") for x in g.group(3).split(",") ] # split by comma and strip for arg_raw in args_raw: # Ex: 'const lv_obj_t * parent' -> 'const ', 'lv_obj_t', ' * ', 'parent' # Ex: 'bool auto_fit' -> '', 'bool', ' ', 'auto_fit' ga = parse_arg.search(arg_raw) if ga: # parsing ok? ga_type = ga.group(2) ga_ptr = ( ga.group(3).strip(" \t\n\r") == "*" ) # boolean ga_name = ga.group(4) ga_type_ptr = ga_type if ga_ptr: ga_type_ptr += " *" if ga_type_ptr in return_types: ga_type = return_types[ga_type_ptr] else: # remove the trailing '_t' of type name if any ga_type = re.sub(r"_t$", "", ga_type) # if the type is a single letter, we just add it if len(ga_type) == 1 and ga_type != 'c': # callbacks are different c_args += ga_type else: if ga_type.endswith("_cb"): # it's a callback type, we encode it differently if ga_type not in lv_cb_types: lv_cb_types.append(ga_type) c_args += "&" + str(lv_cb_types.index(ga_type)) else: # we have a high-level type that we treat as a class name, enclose in parenthesis c_args += "(" + ga_type + ")" # analyze function name and determine if it needs to be assigned to a specific class func_name = g.group(2) # Ex: func_name -> 'lv_obj_set_parent' if func_name.startswith("_"): continue # skip low-level if func_name.startswith("lv_debug_"): continue # skip debug c_func_name = "" if func_name == "lv_style_init": continue # no need for init as it would collied with native init (and called behind the scene anyways) found = False for subtype in lv_prefix: if func_name.startswith("lv_" + subtype + "_"): be_name = re.sub("^lv_" + subtype + "_", '', func_name) c_func_name = "lvbe_" + subtype + "_" + be_name if subtype not in lv: lv[subtype] = [] # add entry # special case if the function is create, we change the return type to macth the class lv[subtype].append( [ c_func_name, c_ret, c_args, func_name, be_name ] ) found = True break if found: continue # not found, we treat it as lv top level function be_name = re.sub("^lv_", '', func_name) lv0.append( [ func_name, c_ret, c_args, func_name, be_name ] ) # print(lv0[-1]) print("| callback types"+str(lv_cb_types)) # parse module file containing numerical constants with open(lv_module_file) as f: for l_raw in f: l_raw = l_raw.strip(" \t\n\r") # remove leading or trailing spaces if l_raw.startswith("//"): 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: 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 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") continue if v_num is not None: lv_module.append( [k, v_num] ) else: lv_module.append( [k, v] ) # keep as string or None # recursively try to match value # TODO # print(lv) #print(f"orig {func_name} berry {c_func_name}") #print(g.group(1)) #print(g.group(2)) #print(g.group(3)) sys.stdout = open(out_prefix + be_lv_defines, 'w') print("/********************************************************************") print(" * Generated code, don't edit") print(" *******************************************************************/") print(" // Configuration") for subtype in lv_widgets: define = f"BE_LV_WIDGET_" + subtype.upper() print(f"#ifndef {define}") print(f"#define {define} 1") print(f"#endif") print("/********************************************************************/") sys.stdout.close() sys.stdout = open(out_prefix + be_lv_c_mapping, 'w') print(""" /******************************************************************** * Generated code, don't edit *******************************************************************/ #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: 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] if c_func_name.endswith("_create"): 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() for subtype in lv: print(f" extern void be_load_lv_{subtype}_lib(bvm *vm);") print() print(f" void be_load_lv_all_lib(bvm *vm) {{") for subtype in lv: define = f"BE_LV_WIDGET_" + subtype.upper() if subtype in lv_widgets: print(f"#if {define}") print(f" be_load_lv_{subtype}_lib(vm);") if subtype in lv_widgets: print(f"#endif") print(f" }};") print("#ifdef __cplusplus") print("} /* extern \"C\" */") print("#endif") print("/********************************************************************/") sys.stdout.close() sys.stdout = open(lvgl_prefix + be_lv_widgets_libs, 'w') print(""" /******************************************************************** * Generated code, don't edit *******************************************************************/ /******************************************************************** * Tasmota LVGL classes for widgets *******************************************************************/ #include "be_constobj.h" #ifdef USE_LVGL #include "lvgl.h" #include "be_lvgl.h" extern int lv0_init(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); extern int lvs_tostring(bvm *vm); BE_EXPORT_VARIABLE extern const bclass be_class_lv_obj; """) for subtype, flv in lv.items(): print(f"/* `lv_{subtype}` external functions definitions */") for f in flv: c_func_name = f[0] print(f"extern int {c_func_name}(bvm *vm);") print() print(""" #if BE_USE_PRECOMPILED_OBJECT """) for subtype, flv in lv.items(): print(f"#include \"../generate/be_fixed_be_class_lv_{subtype}.h\"") print(""" #endif """) print() for subtype, flv in lv.items(): # class definitions print(f"void be_load_lv_{subtype}_lib(bvm *vm) {{") print("#if !BE_USE_PRECOMPILED_OBJECT") print(f" static const bnfuncinfo members[] = {{") print(f" {{ \".p\", NULL }},") if subtype == "style": print(f" {{ \"init\", lvs_init }},") print(f" {{ \"tostring\", lvs_tostring }},") else: if subtype != 'indev': # indev has no create print(f" {{ \"init\", lvbe_{subtype}_create }},") else: print(f" {{ \"init\", lv0_init }},") print(f" {{ \"tostring\", lvx_tostring }},") print(f" {{ \"member\", lvx_member }},") print() # for f in flv: # 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 */") print() print(f" {{ NULL, NULL }}") print(f" }};") print(f" be_regclass(vm, \"lv_{subtype}\", members);") if subtype in lv_widgets: # only for subclasses of lv_obj print() print(f" be_getglobal(vm, \"lv_{subtype}\");") print(f" be_getglobal(vm, \"lv_obj\");") print(f" be_setsuper(vm, -2);") print(f" be_pop(vm, 2);") print("#else") print(f" be_pushntvclass(vm, &be_class_lv_{subtype});") print(f" be_setglobal(vm, \"lv_{subtype}\");") print(f" be_pop(vm, 1);") print("#endif") print(f"}};") print() print(f"/* @const_object_info_begin") if subtype in lv_widgets: # only for subclasses of lv_obj print(f"class be_class_lv_{subtype} (scope: global, name: lv_{subtype}, super: be_class_lv_obj) {{") else: print(f"class be_class_lv_{subtype} (scope: global, name: lv_{subtype}) {{") print(f" .p, var") if subtype == "style": print(f" init, func(lvs_init)") print(f" tostring, func(lvs_tostring)") else: if subtype != 'indev': # indev has no create print(f" init, func(lvbe_{subtype}_create)") 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})") print(f"}}") print(f"@const_object_info_end */") print() print(""" #endif // USE_LVGL """) sys.stdout.close() sys.stdout = open(lvgl_prefix + be_lv_lvgl_module, 'w') print("/********************************************************************") print(" * Generated code, don't edit") print(" *******************************************************************/") print("""/******************************************************************** * LVGL Module *******************************************************************/ #include "be_constobj.h" #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); extern int lv0_register_button_encoder(bvm *vm); // add buttons with encoder logic extern int lv0_load_montserrat_font(bvm *vm); 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_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(void) { return lv_disp_get_ver_res(lv_disp_get_default()); } /* `lv` methods */ const lvbe_call_c_t lv_func[] = { """) func_out = {} # used to sort output for f in lv0: 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] 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]) # // 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" }, print(""" }; const size_t lv_func_size = sizeof(lv_func) / sizeof(lv_func[0]); """) print(""" typedef struct be_constint_t { const char * name; int32_t value; } be_constint_t; const be_constint_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]); #if !BE_USE_PRECOMPILED_OBJECT be_native_module_attr_table(lvgl) { // Symbols be_native_module_str("SYMBOL_AUDIO", "\\xef\\x80\\x81"), be_native_module_str("SYMBOL_VIDEO", "\\xef\\x80\\x88"), be_native_module_str("SYMBOL_LIST", "\\xef\\x80\\x8b"), be_native_module_str("SYMBOL_OK", "\\xef\\x80\\x8c"), be_native_module_str("SYMBOL_CLOSE", "\\xef\\x80\\x8d"), be_native_module_str("SYMBOL_POWER", "\\xef\\x80\\x91"), be_native_module_str("SYMBOL_SETTINGS", "\\xef\\x80\\x93"), be_native_module_str("SYMBOL_HOME", "\\xef\\x80\\x95"), be_native_module_str("SYMBOL_DOWNLOAD", "\\xef\\x80\\x99"), be_native_module_str("SYMBOL_DRIVE", "\\xef\\x80\\x9c"), be_native_module_str("SYMBOL_REFRESH", "\\xef\\x80\\xa1"), be_native_module_str("SYMBOL_MUTE", "\\xef\\x80\\xa6"), be_native_module_str("SYMBOL_VOLUME_MID", "\\xef\\x80\\xa7"), be_native_module_str("SYMBOL_VOLUME_MAX", "\\xef\\x80\\xa8"), be_native_module_str("SYMBOL_IMAGE", "\\xef\\x80\\xbe"), be_native_module_str("SYMBOL_EDIT", "\\xef\\x8C\\x84"), be_native_module_str("SYMBOL_PREV", "\\xef\\x81\\x88"), be_native_module_str("SYMBOL_PLAY", "\\xef\\x81\\x8b"), be_native_module_str("SYMBOL_PAUSE", "\\xef\\x81\\x8c"), be_native_module_str("SYMBOL_STOP", "\\xef\\x81\\x8d"), be_native_module_str("SYMBOL_NEXT", "\\xef\\x81\\x91"), be_native_module_str("SYMBOL_EJECT", "\\xef\\x81\\x92"), be_native_module_str("SYMBOL_LEFT", "\\xef\\x81\\x93"), be_native_module_str("SYMBOL_RIGHT", "\\xef\\x81\\x94"), be_native_module_str("SYMBOL_PLUS", "\\xef\\x81\\xa7"), be_native_module_str("SYMBOL_MINUS", "\\xef\\x81\\xa8"), be_native_module_str("SYMBOL_EYE_OPEN", "\\xef\\x81\\xae"), be_native_module_str("SYMBOL_EYE_CLOSE", "\\xef\\x81\\xb0"), be_native_module_str("SYMBOL_WARNING", "\\xef\\x81\\xb1"), be_native_module_str("SYMBOL_SHUFFLE", "\\xef\\x81\\xb4"), be_native_module_str("SYMBOL_UP", "\\xef\\x81\\xb7"), be_native_module_str("SYMBOL_DOWN", "\\xef\\x81\\xb8"), be_native_module_str("SYMBOL_LOOP", "\\xef\\x81\\xb9"), be_native_module_str("SYMBOL_DIRECTORY", "\\xef\\x81\\xbb"), be_native_module_str("SYMBOL_UPLOAD", "\\xef\\x82\\x93"), be_native_module_str("SYMBOL_CALL", "\\xef\\x82\\x95"), be_native_module_str("SYMBOL_CUT", "\\xef\\x83\\x84"), be_native_module_str("SYMBOL_COPY", "\\xef\\x83\\x85"), be_native_module_str("SYMBOL_SAVE", "\\xef\\x83\\x87"), be_native_module_str("SYMBOL_CHARGE", "\\xef\\x83\\xa7"), be_native_module_str("SYMBOL_PASTE", "\\xef\\x83\\xAA"), be_native_module_str("SYMBOL_BELL", "\\xef\\x83\\xb3"), be_native_module_str("SYMBOL_KEYBOARD", "\\xef\\x84\\x9c"), be_native_module_str("SYMBOL_GPS", "\\xef\\x84\\xa4"), be_native_module_str("SYMBOL_FILE", "\\xef\\x85\\x9b"), be_native_module_str("SYMBOL_WIFI", "\\xef\\x87\\xab"), be_native_module_str("SYMBOL_BATTERY_FULL", "\\xef\\x89\\x80"), be_native_module_str("SYMBOL_BATTERY_3", "\\xef\\x89\\x81"), be_native_module_str("SYMBOL_BATTERY_2", "\\xef\\x89\\x82"), be_native_module_str("SYMBOL_BATTERY_1", "\\xef\\x89\\x83"), be_native_module_str("SYMBOL_BATTERY_EMPTY", "\\xef\\x89\\x84"), be_native_module_str("SYMBOL_USB", "\\xef\\x8a\\x87"), be_native_module_str("SYMBOL_BLUETOOTH", "\\xef\\x8a\\x93"), be_native_module_str("SYMBOL_TRASH", "\\xef\\x8B\\xAD"), be_native_module_str("SYMBOL_BACKSPACE", "\\xef\\x95\\x9A"), be_native_module_str("SYMBOL_SD_CARD", "\\xef\\x9F\\x82"), be_native_module_str("SYMBOL_NEW_LINE", "\\xef\\xA2\\xA2"), be_native_module_str("SYMBOL_DUMMY", "\\xEF\\xA3\\xBF"), be_native_module_str("SYMBOL_BULLET", "\\xE2\\x80\\xA2"), """) print("/* `lvgl` module functions */") print() # for subtype, flv in lv.items(): # if subtype != 'xxx': continue # print(f"/* `lv_{subtype}` external functions definitions */") # for f in flv: # c_func_name = f[0] # print(f"extern int {c_func_name}(bvm *vm);") # print() # 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(""" 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), be_native_module_function("montserrat_font", lv0_load_montserrat_font), be_native_module_function("seg7_font", lv0_load_seg7_font), be_native_module_function("load_font", lv0_load_font), be_native_module_function("load_freetype_font", lv0_load_freetype_font), be_native_module_function("screenshot", lv0_screenshot), }; be_define_native_module(lvgl, NULL); #else be_define_local_const_str(SYMBOL_AUDIO, "\\xef\\x80\\x81", 0, 3); be_define_local_const_str(SYMBOL_VIDEO, "\\xef\\x80\\x88", 0, 3); be_define_local_const_str(SYMBOL_LIST, "\\xef\\x80\\x8b", 0, 3); be_define_local_const_str(SYMBOL_OK, "\\xef\\x80\\x8c", 0, 3); be_define_local_const_str(SYMBOL_CLOSE, "\\xef\\x80\\x8d", 0, 3); be_define_local_const_str(SYMBOL_POWER, "\\xef\\x80\\x91", 0, 3); be_define_local_const_str(SYMBOL_SETTINGS, "\\xef\\x80\\x93", 0, 3); be_define_local_const_str(SYMBOL_HOME, "\\xef\\x80\\x95", 0, 3); be_define_local_const_str(SYMBOL_DOWNLOAD, "\\xef\\x80\\x99", 0, 3); be_define_local_const_str(SYMBOL_DRIVE, "\\xef\\x80\\x9c", 0, 3); be_define_local_const_str(SYMBOL_REFRESH, "\\xef\\x80\\xa1", 0, 3); be_define_local_const_str(SYMBOL_MUTE, "\\xef\\x80\\xa6", 0, 3); be_define_local_const_str(SYMBOL_VOLUME_MID, "\\xef\\x80\\xa7", 0, 3); be_define_local_const_str(SYMBOL_VOLUME_MAX, "\\xef\\x80\\xa8", 0, 3); be_define_local_const_str(SYMBOL_IMAGE, "\\xef\\x80\\xbe", 0, 3); be_define_local_const_str(SYMBOL_EDIT, "\\xef\\x8C\\x84", 0, 3); be_define_local_const_str(SYMBOL_PREV, "\\xef\\x81\\x88", 0, 3); be_define_local_const_str(SYMBOL_PLAY, "\\xef\\x81\\x8b", 0, 3); be_define_local_const_str(SYMBOL_PAUSE, "\\xef\\x81\\x8c", 0, 3); be_define_local_const_str(SYMBOL_STOP, "\\xef\\x81\\x8d", 0, 3); be_define_local_const_str(SYMBOL_NEXT, "\\xef\\x81\\x91", 0, 3); be_define_local_const_str(SYMBOL_EJECT, "\\xef\\x81\\x92", 0, 3); be_define_local_const_str(SYMBOL_LEFT, "\\xef\\x81\\x93", 0, 3); be_define_local_const_str(SYMBOL_RIGHT, "\\xef\\x81\\x94", 0, 3); be_define_local_const_str(SYMBOL_PLUS, "\\xef\\x81\\xa7", 0, 3); be_define_local_const_str(SYMBOL_MINUS, "\\xef\\x81\\xa8", 0, 3); be_define_local_const_str(SYMBOL_EYE_OPEN, "\\xef\\x81\\xae", 0, 3); be_define_local_const_str(SYMBOL_EYE_CLOSE, "\\xef\\x81\\xb0", 0, 3); be_define_local_const_str(SYMBOL_WARNING, "\\xef\\x81\\xb1", 0, 3); be_define_local_const_str(SYMBOL_SHUFFLE, "\\xef\\x81\\xb4", 0, 3); be_define_local_const_str(SYMBOL_UP, "\\xef\\x81\\xb7", 0, 3); be_define_local_const_str(SYMBOL_DOWN, "\\xef\\x81\\xb8", 0, 3); be_define_local_const_str(SYMBOL_LOOP, "\\xef\\x81\\xb9", 0, 3); be_define_local_const_str(SYMBOL_DIRECTORY, "\\xef\\x81\\xbb", 0, 3); be_define_local_const_str(SYMBOL_UPLOAD, "\\xef\\x82\\x93", 0, 3); be_define_local_const_str(SYMBOL_CALL, "\\xef\\x82\\x95", 0, 3); be_define_local_const_str(SYMBOL_CUT, "\\xef\\x83\\x84", 0, 3); be_define_local_const_str(SYMBOL_COPY, "\\xef\\x83\\x85", 0, 3); be_define_local_const_str(SYMBOL_SAVE, "\\xef\\x83\\x87", 0, 3); be_define_local_const_str(SYMBOL_CHARGE, "\\xef\\x83\\xa7", 0, 3); be_define_local_const_str(SYMBOL_PASTE, "\\xef\\x83\\xAA", 0, 3); be_define_local_const_str(SYMBOL_BELL, "\\xef\\x83\\xb3", 0, 3); be_define_local_const_str(SYMBOL_KEYBOARD, "\\xef\\x84\\x9c", 0, 3); be_define_local_const_str(SYMBOL_GPS, "\\xef\\x84\\xa4", 0, 3); be_define_local_const_str(SYMBOL_FILE, "\\xef\\x85\\x9b", 0, 3); be_define_local_const_str(SYMBOL_WIFI, "\\xef\\x87\\xab", 0, 3); be_define_local_const_str(SYMBOL_BATTERY_FULL, "\\xef\\x89\\x80", 0, 3); be_define_local_const_str(SYMBOL_BATTERY_3, "\\xef\\x89\\x81", 0, 3); be_define_local_const_str(SYMBOL_BATTERY_2, "\\xef\\x89\\x82", 0, 3); be_define_local_const_str(SYMBOL_BATTERY_1, "\\xef\\x89\\x83", 0, 3); be_define_local_const_str(SYMBOL_BATTERY_EMPTY, "\\xef\\x89\\x84", 0, 3); be_define_local_const_str(SYMBOL_USB, "\\xef\\x8a\\x87", 0, 3); be_define_local_const_str(SYMBOL_BLUETOOTH, "\\xef\\x8a\\x93", 0, 3); be_define_local_const_str(SYMBOL_TRASH, "\\xef\\x8B\\xAD", 0, 3); be_define_local_const_str(SYMBOL_BACKSPACE, "\\xef\\x95\\x9A", 0, 3); be_define_local_const_str(SYMBOL_SD_CARD, "\\xef\\x9F\\x82", 0, 3); be_define_local_const_str(SYMBOL_NEW_LINE, "\\xef\\xA2\\xA2", 0, 3); be_define_local_const_str(SYMBOL_DUMMY, "\\xEF\\xA3\\xBF", 0, 3); be_define_local_const_str(SYMBOL_BULLET, "\\xE2\\x80\\xA2", 0, 3); /* @const_object_info_begin module lvgl (scope: global) { SYMBOL_AUDIO, str(&be_local_const_str_SYMBOL_AUDIO) SYMBOL_VIDEO, str(&be_local_const_str_SYMBOL_VIDEO) SYMBOL_LIST, str(&be_local_const_str_SYMBOL_LIST) SYMBOL_OK, str(&be_local_const_str_SYMBOL_OK) SYMBOL_CLOSE, str(&be_local_const_str_SYMBOL_CLOSE) SYMBOL_POWER, str(&be_local_const_str_SYMBOL_POWER) SYMBOL_SETTINGS, str(&be_local_const_str_SYMBOL_SETTINGS) SYMBOL_HOME, str(&be_local_const_str_SYMBOL_HOME) SYMBOL_DOWNLOAD, str(&be_local_const_str_SYMBOL_DOWNLOAD) SYMBOL_DRIVE, str(&be_local_const_str_SYMBOL_DRIVE) SYMBOL_REFRESH, str(&be_local_const_str_SYMBOL_REFRESH) SYMBOL_MUTE, str(&be_local_const_str_SYMBOL_MUTE) SYMBOL_VOLUME_MID, str(&be_local_const_str_SYMBOL_VOLUME_MID) SYMBOL_VOLUME_MAX, str(&be_local_const_str_SYMBOL_VOLUME_MAX) SYMBOL_IMAGE, str(&be_local_const_str_SYMBOL_IMAGE) SYMBOL_EDIT, str(&be_local_const_str_SYMBOL_EDIT) SYMBOL_PREV, str(&be_local_const_str_SYMBOL_PREV) SYMBOL_PLAY, str(&be_local_const_str_SYMBOL_PLAY) SYMBOL_PAUSE, str(&be_local_const_str_SYMBOL_PAUSE) SYMBOL_STOP, str(&be_local_const_str_SYMBOL_STOP) SYMBOL_NEXT, str(&be_local_const_str_SYMBOL_NEXT) SYMBOL_EJECT, str(&be_local_const_str_SYMBOL_EJECT) SYMBOL_LEFT, str(&be_local_const_str_SYMBOL_LEFT) SYMBOL_RIGHT, str(&be_local_const_str_SYMBOL_RIGHT) SYMBOL_PLUS, str(&be_local_const_str_SYMBOL_PLUS) SYMBOL_MINUS, str(&be_local_const_str_SYMBOL_MINUS) SYMBOL_EYE_OPEN, str(&be_local_const_str_SYMBOL_EYE_OPEN) SYMBOL_EYE_CLOSE, str(&be_local_const_str_SYMBOL_EYE_CLOSE) SYMBOL_WARNING, str(&be_local_const_str_SYMBOL_WARNING) SYMBOL_SHUFFLE, str(&be_local_const_str_SYMBOL_SHUFFLE) SYMBOL_UP, str(&be_local_const_str_SYMBOL_UP) SYMBOL_DOWN, str(&be_local_const_str_SYMBOL_DOWN) SYMBOL_LOOP, str(&be_local_const_str_SYMBOL_LOOP) SYMBOL_DIRECTORY, str(&be_local_const_str_SYMBOL_DIRECTORY) SYMBOL_UPLOAD, str(&be_local_const_str_SYMBOL_UPLOAD) SYMBOL_CALL, str(&be_local_const_str_SYMBOL_CALL) SYMBOL_CUT, str(&be_local_const_str_SYMBOL_CUT) SYMBOL_COPY, str(&be_local_const_str_SYMBOL_COPY) SYMBOL_SAVE, str(&be_local_const_str_SYMBOL_SAVE) SYMBOL_CHARGE, str(&be_local_const_str_SYMBOL_CHARGE) SYMBOL_PASTE, str(&be_local_const_str_SYMBOL_PASTE) SYMBOL_BELL, str(&be_local_const_str_SYMBOL_BELL) SYMBOL_KEYBOARD, str(&be_local_const_str_SYMBOL_KEYBOARD) SYMBOL_GPS, str(&be_local_const_str_SYMBOL_GPS) SYMBOL_FILE, str(&be_local_const_str_SYMBOL_FILE) SYMBOL_WIFI, str(&be_local_const_str_SYMBOL_WIFI) SYMBOL_BATTERY_FULL, str(&be_local_const_str_SYMBOL_BATTERY_FULL) SYMBOL_BATTERY_3, str(&be_local_const_str_SYMBOL_BATTERY_3) SYMBOL_BATTERY_2, str(&be_local_const_str_SYMBOL_BATTERY_2) SYMBOL_BATTERY_1, str(&be_local_const_str_SYMBOL_BATTERY_1) SYMBOL_BATTERY_EMPTY, str(&be_local_const_str_SYMBOL_BATTERY_EMPTY) SYMBOL_USB, str(&be_local_const_str_SYMBOL_USB) SYMBOL_BLUETOOTH, str(&be_local_const_str_SYMBOL_BLUETOOTH) SYMBOL_TRASH, str(&be_local_const_str_SYMBOL_TRASH) SYMBOL_BACKSPACE, str(&be_local_const_str_SYMBOL_BACKSPACE) SYMBOL_SD_CARD, str(&be_local_const_str_SYMBOL_SD_CARD) SYMBOL_NEW_LINE, str(&be_local_const_str_SYMBOL_NEW_LINE) SYMBOL_DUMMY, str(&be_local_const_str_SYMBOL_DUMMY) SYMBOL_BULLET, str(&be_local_const_str_SYMBOL_BULLET) """) # for k_v in lv_module: # (k,v) = k_v # if k is None: # continue # print(f" {k}, int({v})") print(""" member, func(lv0_member) start, func(lv0_start) register_button_encoder, func(lv0_register_button_encoder) montserrat_font, func(lv0_load_montserrat_font) seg7_font, func(lv0_load_seg7_font) load_font, func(lv0_load_font) load_freetype_font, func(lv0_load_freetype_font) screenshot, func(lv0_screenshot) } @const_object_info_end */ #include "../generate/be_fixed_lvgl.h" #endif #endif // USE_LVGL """) print("/********************************************************************/") sys.stdout.close()