jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-24 19:26:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #14111 from s-hadinger/lib_lv_berry

Browse Source 
Berry created separate library `lv_berry` to isolate LVGL-Berry mapping
This commit is contained in:
s-hadinger 2021-12-20 16:43:41 +01:00 committed by GitHub
commit 4b2ea37360
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 1942 additions and 2814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/libesp32/berry/generate/be_const_strtab.h
View File

@ -206,6 +206,7 @@ extern const bcstring be_const_str_add;
extern const bcstring be_const_str_add_anim; extern const bcstring be_const_str_add_anim;
extern const bcstring be_const_str_add_cmd; extern const bcstring be_const_str_add_cmd;
extern const bcstring be_const_str_add_driver; extern const bcstring be_const_str_add_driver;
extern const bcstring be_const_str_add_handler;
extern const bcstring be_const_str_add_header; extern const bcstring be_const_str_add_header;
extern const bcstring be_const_str_add_rule; extern const bcstring be_const_str_add_rule;
extern const bcstring be_const_str_addr; extern const bcstring be_const_str_addr;
@ -464,6 +465,7 @@ extern const bcstring be_const_str_length_X20in_X20bits_X20must_X20be_X20between
extern const bcstring be_const_str_light; extern const bcstring be_const_str_light;
extern const bcstring be_const_str_line_dsc; extern const bcstring be_const_str_line_dsc;
extern const bcstring be_const_str_list; extern const bcstring be_const_str_list;
extern const bcstring be_const_str_list_handlers;
extern const bcstring be_const_str_listdir; extern const bcstring be_const_str_listdir;
extern const bcstring be_const_str_load; extern const bcstring be_const_str_load;
extern const bcstring be_const_str_load_templates; extern const bcstring be_const_str_load_templates;
@ -473,11 +475,13 @@ extern const bcstring be_const_str_log10;
extern const bcstring be_const_str_loop; extern const bcstring be_const_str_loop;
extern const bcstring be_const_str_lower; extern const bcstring be_const_str_lower;
extern const bcstring be_const_str_lv; extern const bcstring be_const_str_lv;
extern const bcstring be_const_str_lv_;
extern const bcstring be_const_str_lv_event; extern const bcstring be_const_str_lv_event;
extern const bcstring be_const_str_lv_event_cb; extern const bcstring be_const_str_lv_event_cb;
extern const bcstring be_const_str_lv_obj; extern const bcstring be_const_str_lv_obj;
extern const bcstring be_const_str_lv_obj_class; extern const bcstring be_const_str_lv_obj_class;
extern const bcstring be_const_str_lvgl_event_dispatch; extern const bcstring be_const_str_lvgl_event_dispatch;
extern const bcstring be_const_str_make_cb;
extern const bcstring be_const_str_map; extern const bcstring be_const_str_map;
extern const bcstring be_const_str_math; extern const bcstring be_const_str_math;
extern const bcstring be_const_str_matrix; extern const bcstring be_const_str_matrix;

1834
lib/libesp32/berry/generate/be_const_strtab_def.h
View File

File diff suppressed because it is too large Load Diff

5
lib/libesp32/berry/generate/be_fixed_cb.h
View File

@ -1,13 +1,16 @@
#include "be_constobj.h" #include "be_constobj.h"
static be_define_const_map_slots(m_libcb_map) { static be_define_const_map_slots(m_libcb_map) {
{ be_const_key(make_cb, -1), be_const_func(be_cb_make_cb) },
{ be_const_key(list_handlers, 3), be_const_func(be_cb_list_handlers) },
{ be_const_key(get_cb_list, -1), be_const_func(be_cb_get_cb_list) }, { be_const_key(get_cb_list, -1), be_const_func(be_cb_get_cb_list) },
{ be_const_key(gen_cb, -1), be_const_func(be_cb_gen_cb) }, { be_const_key(gen_cb, -1), be_const_func(be_cb_gen_cb) },
{ be_const_key(add_handler, -1), be_const_func(be_cb_add_handler) },
}; };
static be_define_const_map( static be_define_const_map(
m_libcb_map, m_libcb_map,
2 5
); );
static be_define_const_module( static be_define_const_module(

130
lib/libesp32/berry_mapping/src/be_cb_module.c
View File

@ -10,6 +10,7 @@
#include "be_gc.h" #include "be_gc.h"
#include "be_exec.h" #include "be_exec.h"
#include "be_vm.h" #include "be_vm.h"
#include "be_mem.h"
/*********************************************************************************************\ /*********************************************************************************************\
* Callback structures * Callback structures
@ -69,11 +70,115 @@ static const berry_callback_t berry_callback_array[BE_MAX_CB] = {
typedef struct be_callback_hook { typedef struct be_callback_hook {
bvm *vm; bvm *vm;
bgcobject *f; bvalue f;
} be_callback_hook; } be_callback_hook;
typedef struct be_callback_handler_list_t {
bvm *vm;
bvalue f;
struct be_callback_handler_list_t *next;
} be_callback_handler_list_t;
static be_callback_hook be_cb_hooks[BE_MAX_CB] = {0}; static be_callback_hook be_cb_hooks[BE_MAX_CB] = {0};
static int32_t be_cb_gen_cb(bvm *vm);
static be_callback_handler_list_t be_callback_default_gen_cb = {
NULL,
be_const_func(&be_cb_gen_cb),
NULL
};
static be_callback_handler_list_t *be_callback_handler_list_head = &be_callback_default_gen_cb; /* linked list of handlers */
/*********************************************************************************************\
* `add_handler`: Add an external handler to `make_cb()`
*
* This is typically used by LVGL mapping to handle widget callbacks, the handler
* needs to record additional infomation to disambiguate the call
*
* arg1: function (or closure)
\*********************************************************************************************/
static int32_t be_cb_add_handler(bvm *vm) {
int32_t top = be_top(vm);
if (top >= 1 && be_isfunction(vm, 1)) {
bvalue *v = be_indexof(vm, 1);
be_callback_handler_list_t *elt = be_os_malloc(sizeof(be_callback_handler_list_t));
if (!elt) { be_throw(vm, BE_MALLOC_FAIL); }
if (be_isgcobj(v)) {
be_gc_fix_set(vm, v->v.gc, btrue); // mark the function as non-gc
}
elt->vm = vm;
elt->f = *v;
elt->next = be_callback_handler_list_head; /* insert as new head */
be_callback_handler_list_head = elt;
be_return_nil(vm);
}
be_raise(vm, "value_error", "arg must be a function");
}
/*********************************************************************************************\
* `list_handlers`: List all cb handlers registered for this VM
*
* Used for debugging only
*
* No args
\*********************************************************************************************/
static int32_t be_cb_list_handlers(bvm *vm) {
be_newobject(vm, "list");
for (be_callback_handler_list_t *elt = be_callback_handler_list_head; elt != NULL; elt = elt->next) {
if (elt->vm == vm) { /* on purpose don't show the default handler, just pretend it's not there since it's default */
bvalue *top = be_incrtop(vm);
*top = elt->f;
be_data_push(vm, -2);
be_pop(vm, 1);
}
}
be_pop(vm, 1);
be_return(vm);
}
/*********************************************************************************************\
* `make_cb`: high-level call for creating a callback.
*
* This function is called by `be_mapping` when generating a callback with a type name.
* LVGL typically needs to register typed callbacks
*
* arg1: function (or closure)
* arg2: type name for callback (optional)
* argN: any other callback specific arguments (unlimited number, passed as-is)
\*********************************************************************************************/
static int32_t be_cb_make_cb(bvm *vm) {
int32_t argc = be_top(vm);
if (argc >= 1 && be_isfunction(vm, 1)) {
bvalue *v = be_indexof(vm, 1);
for (be_callback_handler_list_t *elt = be_callback_handler_list_head; elt != NULL; elt = elt->next) {
if (elt->vm == vm || elt->vm == NULL) { // if elt->vm is NULL then we accept any VM
// call the handler and check result
bvalue *top = be_incrtop(vm);
*top = elt->f;
// var_setobj(top, elt->f->type, elt->f); // push function - arg0
for (int i=1; i<=argc; i++) { // push all arguments including function
be_pushvalue(vm, i);
}
be_call(vm, argc); // call handler
be_pop(vm, argc); // remove arguments, top of stack has the result
// if top of stack is `comptr` then it is successful
if (be_iscomptr(vm, -1)) {
be_return(vm);
} else {
be_pop(vm, 1); // remove top, rinse and repeat
}
}
}
// if we are here, it means that no handler has handled the request
}
be_raise(vm, "value_error", "arg must be a function");
}
/*********************************************************************************************\ /*********************************************************************************************\
* `gen_cb`: Generate a new callback * `gen_cb`: Generate a new callback
* *
@ -85,17 +190,16 @@ static int32_t be_cb_gen_cb(bvm *vm) {
// find first available slot // find first available slot
int32_t slot; int32_t slot;
for (slot = 0; slot < BE_MAX_CB; slot++) { for (slot = 0; slot < BE_MAX_CB; slot++) {
if (be_cb_hooks[slot].f == NULL) break; if (be_cb_hooks[slot].f.type == BE_NIL) break;
} }
bvalue *v = be_indexof(vm, 1); bvalue *v = be_indexof(vm, 1);
if (slot < BE_MAX_CB) { if (slot < BE_MAX_CB) {
// found a free slot if (be_isgcobj(v)) {
bgcobject * f = v->v.gc; be_gc_fix_set(vm, v->v.gc, btrue); // mark the function as non-gc
// mark the function as non-gc }
be_gc_fix_set(vm, f, btrue);
// record pointers // record pointers
be_cb_hooks[slot].vm = vm; be_cb_hooks[slot].vm = vm;
be_cb_hooks[slot].f = f; be_cb_hooks[slot].f = *v;
be_pushcomptr(vm, (void*) berry_callback_array[slot]); be_pushcomptr(vm, (void*) berry_callback_array[slot]);
be_return(vm); be_return(vm);
} else { } else {
@ -115,7 +219,9 @@ static int32_t be_cb_get_cb_list(bvm *vm) {
for (uint32_t i=0; i < BE_MAX_CB; i++) { for (uint32_t i=0; i < BE_MAX_CB; i++) {
if (be_cb_hooks[i].vm) { if (be_cb_hooks[i].vm) {
if (vm == be_cb_hooks[i].vm) { // make sure it corresponds to this vm if (vm == be_cb_hooks[i].vm) { // make sure it corresponds to this vm
be_pushcomptr(vm, be_cb_hooks[i].f); bvalue *top = be_incrtop(vm);
*top = be_cb_hooks[i].f;
// be_pushcomptr(vm, be_cb_hooks[i].f);
be_data_push(vm, -2); be_data_push(vm, -2);
be_pop(vm, 1); be_pop(vm, 1);
} }
@ -140,11 +246,11 @@ static int32_t call_berry_cb(int32_t num, int32_t v0, int32_t v1, int32_t v2, in
if (num < 0 || num >= BE_MAX_CB || be_cb_hooks[num].vm == NULL) return 0; // invalid call, avoid a crash if (num < 0 || num >= BE_MAX_CB || be_cb_hooks[num].vm == NULL) return 0; // invalid call, avoid a crash
bvm * vm = be_cb_hooks[num].vm; bvm * vm = be_cb_hooks[num].vm;
bgcobject * f = be_cb_hooks[num].f; bvalue *f = &be_cb_hooks[num].f;
// push function (don't check type) // push function (don't check type)
bvalue *top = be_incrtop(vm); bvalue *top = be_incrtop(vm);
var_setobj(top, f->type, f); *top = *f;
// push args // push args
be_pushint(vm, v0); be_pushint(vm, v0);
be_pushint(vm, v1); be_pushint(vm, v1);
@ -166,6 +272,10 @@ static int32_t call_berry_cb(int32_t num, int32_t v0, int32_t v1, int32_t v2, in
module cb (scope: global) { module cb (scope: global) {
gen_cb, func(be_cb_gen_cb) gen_cb, func(be_cb_gen_cb)
get_cb_list, func(be_cb_get_cb_list) get_cb_list, func(be_cb_get_cb_list)
add_handler, func(be_cb_add_handler)
list_handlers, func(be_cb_list_handlers)
make_cb, func(be_cb_make_cb)
} }
@const_object_info_end */ @const_object_info_end */
#include "../../berry/generate/be_fixed_cb.h" #include "../../berry/generate/be_fixed_cb.h"

59
lib/libesp32/berry_mapping/src/be_class_wrapper.c
View File

@ -21,6 +21,24 @@ void be_set_gen_cb_name(bvm *vm, const char * gen_cb) {
if (gen_cb) be_gen_cb_name = gen_cb; if (gen_cb) be_gen_cb_name = gen_cb;
} }
/*********************************************************************************************\
* Converision from real <-> int
*
* Warning, works only if sizeof(intptr_t) == sizeof(breal)
* On ESP32, int=32bits, real=float (32bits)
\*********************************************************************************************/
static intptr_t realasint(breal v) {
intptr_t i;
i = *((intptr_t*) &v);
return i;
}
static breal intasreal(intptr_t v) {
breal r;
r = *((breal*) &v);
return r;
}
/*********************************************************************************************\ /*********************************************************************************************\
* Create an object of `class_name` given an external poinrt `ptr`. * Create an object of `class_name` given an external poinrt `ptr`.
* *
@ -73,7 +91,14 @@ int be_find_global_or_module_member(bvm *vm, const char * name) {
char * prefix = strtok_r(name_buf, ".", &saveptr); char * prefix = strtok_r(name_buf, ".", &saveptr);
char * suffix = strtok_r(NULL, ".", &saveptr); char * suffix = strtok_r(NULL, ".", &saveptr);
if (suffix) { if (suffix) {
if (be_getglobal(vm, prefix)) { if (!be_getglobal(vm, prefix)) {
// global not found, try module
be_pop(vm, 1);
if (!be_getmodule(vm, prefix)) {
return 0;
}
}
if (!be_isnil(vm, -1)) {
if (be_getmember(vm, -1, suffix)) { if (be_getmember(vm, -1, suffix)) {
if (be_isinstance(vm, -2)) { // instance, so we need to push method + instance if (be_isinstance(vm, -2)) { // instance, so we need to push method + instance
be_pushvalue(vm, -2); be_pushvalue(vm, -2);
@ -123,7 +148,7 @@ int be_find_global_or_module_member(bvm *vm, const char * name) {
* 's' be_str * 's' be_str
* *
* - arg_type: optionally check the types of input arguments, or throw an error * - arg_type: optionally check the types of input arguments, or throw an error
* string of argument types * string of argument types, '[' indicates that the following parameters are optional
* '.' don't care * '.' don't care
* 'i' be_int * 'i' be_int
* 'b' be_bool * 'b' be_bool
@ -141,7 +166,7 @@ int be_find_global_or_module_member(bvm *vm, const char * name) {
// read a single value at stack position idx, convert to int. // read a single value at stack position idx, convert to int.
// if object instance, get `_p` member and convert it recursively // if object instance, get `_p` member and convert it recursively
intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const char * gen_cb) { intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const char * gen_cb) {
// berry_log_C("be_convert_single_elt(idx=%i, argtype='%s', gen_cb=%p", idx, arg_type, gen_cb); // berry_log_C("be_convert_single_elt(idx=%i, argtype='%s', gen_cb=%p, type=%s", idx, arg_type ? arg_type : "", gen_cb ? gen_cb : "", be_typename(vm, idx));
int ret = 0; int ret = 0;
char provided_type = 0; char provided_type = 0;
idx = be_absindex(vm, idx); // make sure we have an absolute index idx = be_absindex(vm, idx); // make sure we have an absolute index
@ -156,7 +181,6 @@ intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const ch
if (be_isclosure(vm, idx)) { if (be_isclosure(vm, idx)) {
ret = be_find_global_or_module_member(vm, gen_cb); ret = be_find_global_or_module_member(vm, gen_cb);
if (ret) { if (ret) {
be_remove(vm, -3); // stack contains method + instance
be_pushvalue(vm, idx); be_pushvalue(vm, idx);
be_pushvalue(vm, 1); be_pushvalue(vm, 1);
be_pushstring(vm, arg_type); be_pushstring(vm, arg_type);
@ -175,18 +199,24 @@ intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const ch
} }
// first convert the value to int32 // first convert the value to int32
if (be_isint(vm, idx)) { ret = be_toint(vm, idx); provided_type = 'i'; } if (be_isint(vm, idx)) {
if (arg_type[0] == 'f') {
ret = realasint((float)be_toint(vm, idx)); provided_type = 'f';
} else {
ret = be_toint(vm, idx); provided_type = 'i'; }
}
else if (be_isbool(vm, idx)) { ret = be_tobool(vm, idx); provided_type = 'b'; } else if (be_isbool(vm, idx)) { ret = be_tobool(vm, idx); provided_type = 'b'; }
else if (be_isstring(vm, idx)) { ret = (intptr_t) be_tostring(vm, idx); provided_type = 's'; } else if (be_isstring(vm, idx)) { ret = (intptr_t) be_tostring(vm, idx); provided_type = 's'; }
else if (be_iscomptr(vm, idx)) { ret = (intptr_t) be_tocomptr(vm, idx); provided_type = 'c'; } else if (be_iscomptr(vm, idx)) { ret = (intptr_t) be_tocomptr(vm, idx); provided_type = 'c'; }
else if (be_isnil(vm, idx)) { ret = 0; provided_type = 'c'; } else if (be_isnil(vm, idx)) { ret = 0; provided_type = 'c'; }
else if (be_isreal(vm, idx)) { ret = realasint(be_toreal(vm, idx)); provided_type = 'f'; }
// check if simple type was a match // check if simple type was a match
if (provided_type) { if (provided_type) {
bbool type_ok = bfalse; bbool type_ok = bfalse;
type_ok = (arg_type[0] == '.'); // any type is accepted type_ok = (arg_type[0] == '.'); // any type is accepted
type_ok = type_ok || (arg_type[0] == provided_type); // or type is a match type_ok = type_ok || (arg_type[0] == provided_type); // or type is a match
type_ok = type_ok || (ret == 0 && arg_type_len != 1); // or NULL is accepted for an instance type_ok = type_ok || (ret == 0 && arg_type_len != 1); // or NULL is accepted for an instance
if (!type_ok) { if (!type_ok) {
be_raisef(vm, "type_error", "Unexpected argument type '%c', expected '%s'", provided_type, arg_type); be_raisef(vm, "type_error", "Unexpected argument type '%c', expected '%s'", provided_type, arg_type);
@ -195,7 +225,6 @@ intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const ch
return ret; return ret;
} }
// berry_log_C("be_convert_single_elt non simple type");
// non-simple type // non-simple type
if (be_isinstance(vm, idx)) { if (be_isinstance(vm, idx)) {
// check if the instance is a subclass of `bytes()`` // check if the instance is a subclass of `bytes()``
@ -265,6 +294,7 @@ intptr_t be_convert_single_elt(bvm *vm, int idx, const char * arg_type, const ch
void be_check_arg_type(bvm *vm, int arg_start, int argc, const char * arg_type, intptr_t p[8]) { void be_check_arg_type(bvm *vm, int arg_start, int argc, const char * arg_type, intptr_t p[8]) {
bbool arg_type_check = (arg_type != NULL); // is type checking activated bbool arg_type_check = (arg_type != NULL); // is type checking activated
int32_t arg_idx = 0; // position in arg_type string int32_t arg_idx = 0; // position in arg_type string
bbool arg_optional = bfalse; // are remaining types optional?
char type_short_name[32]; char type_short_name[32];
uint32_t p_idx = 0; // index in p[], is incremented with each parameter except '-' uint32_t p_idx = 0; // index in p[], is incremented with each parameter except '-'
@ -272,6 +302,10 @@ void be_check_arg_type(bvm *vm, int arg_start, int argc, const char * arg_type,
type_short_name[0] = 0; // clear string type_short_name[0] = 0; // clear string
// extract individual type // extract individual type
if (NULL != arg_type) { if (NULL != arg_type) {
if (arg_type[arg_idx] == '[' || arg_type[arg_idx] == ']') { // '[' is a marker that following parameters are optional and default to NULL
arg_optional = btrue;
arg_idx++;
}
switch (arg_type[arg_idx]) { switch (arg_type[arg_idx]) {
case '-': case '-':
arg_idx++; arg_idx++;
@ -310,11 +344,13 @@ void be_check_arg_type(bvm *vm, int arg_start, int argc, const char * arg_type,
} }
} }
// AddLog(LOG_LEVEL_INFO, ">> be_call_c_func arg %i, type %s", i, arg_type_check ? type_short_name : "<null>"); // AddLog(LOG_LEVEL_INFO, ">> be_call_c_func arg %i, type %s", i, arg_type_check ? type_short_name : "<null>");
p[p_idx++] = be_convert_single_elt(vm, i + arg_start, arg_type_check ? type_short_name : NULL, be_gen_cb_name); p[p_idx] = be_convert_single_elt(vm, i + arg_start, arg_type_check ? type_short_name : NULL, "cb.make_cb");
// berry_log_C("< ret[%i]=%i", p_idx, p[p_idx]);
p_idx++;
} }
// check if we are missing arguments // check if we are missing arguments
if (arg_type != NULL && arg_type[arg_idx] != 0) { if (!arg_optional && arg_type != NULL && arg_type[arg_idx] != 0) {
be_raisef(vm, "value_error", "Missing arguments, remaining type '%s'", &arg_type[arg_idx]); be_raisef(vm, "value_error", "Missing arguments, remaining type '%s'", &arg_type[arg_idx]);
} }
} }
@ -337,7 +373,7 @@ void be_check_arg_type(bvm *vm, int arg_start, int argc, const char * arg_type,
// `+` forbids any NULL value (raises an exception) while `=` allows a NULL value // `+` forbids any NULL value (raises an exception) while `=` allows a NULL value
static void be_set_ctor_ptr(bvm *vm, void * ptr, const char *name) { static void be_set_ctor_ptr(bvm *vm, void * ptr, const char *name) {
if (name == NULL) return; // do nothing if no name of attribute if (name == NULL) return; // do nothing if no name of attribute
if (name[0] == '=' && ptr == NULL) { be_raise(vm, "value_error", "argument cannot be NULL"); } if (name[0] == '+' && ptr == NULL) { be_raise(vm, "value_error", "argument cannot be NULL"); }
if (name[0] == '+' || name[0] == '=') { name++; } // skip prefix '^' if any if (name[0] == '+' || name[0] == '=') { name++; } // skip prefix '^' if any
if (strlen(name) == 0) return; // do nothing if name is empty if (strlen(name) == 0) return; // do nothing if name is empty
@ -386,7 +422,8 @@ int be_call_c_func(bvm *vm, void * func, const char * return_type, const char *
fn_any_callable f = (fn_any_callable) func; fn_any_callable f = (fn_any_callable) func;
be_check_arg_type(vm, arg_start, arg_count, arg_type, p); be_check_arg_type(vm, arg_start, arg_count, arg_type, p);
intptr_t ret = (*f)(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); intptr_t ret = 0;
if (f) ret = (*f)(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
// berry_log_C("be_call_c_func '%s' -> '%s': (%i,%i,%i,%i,%i,%i) -> %i", return_type, arg_type, p[0], p[1], p[2], p[3], p[4], p[5], ret); // berry_log_C("be_call_c_func '%s' -> '%s': (%i,%i,%i,%i,%i,%i) -> %i", return_type, arg_type, p[0], p[1], p[2], p[3], p[4], p[5], ret);
if ((return_type == NULL) || (strlen(return_type) == 0)) { be_return_nil(vm); } // does not return if ((return_type == NULL) || (strlen(return_type) == 0)) { be_return_nil(vm); } // does not return

30
lib/libesp32_lvgl/lv_berry/generate/be_lvgl_widgets_lib.c
View File

@ -16,11 +16,11 @@ extern int lco_init(bvm *vm); // generic function
extern int lco_tostring(bvm *vm); // generic function extern int lco_tostring(bvm *vm); // generic function
extern int lco_toint(bvm *vm); // generic function extern int lco_toint(bvm *vm); // generic function
extern int lvx_member(bvm *vm); extern int lv_x_member(bvm *vm);
extern int lvx_tostring(bvm *vm); // generic function extern int lv_x_tostring(bvm *vm); // generic function
extern int lvs_init(bvm *vm); extern int lvs_init(bvm *vm);
extern int lvs_tostring(bvm *vm); extern int lv_x_tostring(bvm *vm);
BE_EXPORT_VARIABLE extern const bclass be_class_lv_obj; BE_EXPORT_VARIABLE extern const bclass be_class_lv_obj;
@ -877,9 +877,9 @@ be_local_class(lv_style,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvs_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvs_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvs_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_style", -143355747, 8)) (be_nested_const_str("lv_style", -143355747, 8))
); );
@ -893,8 +893,8 @@ be_local_class(lv_obj,
NULL, NULL,
be_nested_map(5, be_nested_map(5,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("tostring", -1995258651, 8, 3), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, 3), be_const_func(lv_x_tostring) },
{ be_nested_key("member", 719708611, 6, -1), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, -1), be_const_func(lv_x_member) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("init", 380752755, 4, 4), be_const_func(be_ntv_lv_obj_init) }, { be_nested_key("init", 380752755, 4, 4), be_const_func(be_ntv_lv_obj_init) },
{ be_nested_key("_class", -1562820946, 6, -1), be_const_comptr(&lv_obj_class) }, { be_nested_key("_class", -1562820946, 6, -1), be_const_comptr(&lv_obj_class) },
@ -912,9 +912,9 @@ be_local_class(lv_group,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(be_ntv_lv_group_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(be_ntv_lv_group_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_group", -442928277, 8)) (be_nested_const_str("lv_group", -442928277, 8))
); );
@ -929,9 +929,9 @@ be_local_class(lv_indev,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_indev", 225602374, 8)) (be_nested_const_str("lv_indev", 225602374, 8))
); );
@ -946,9 +946,9 @@ be_local_class(lv_disp,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_disp", 609712084, 8)) (be_nested_const_str("lv_disp", 609712084, 8))
); );
@ -963,7 +963,7 @@ be_local_class(lv_font,
be_nested_map(3, be_nested_map(3,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_font_create) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_font_create) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
})), })),
(be_nested_const_str("lv_font", 1550958453, 7)) (be_nested_const_str("lv_font", 1550958453, 7))
@ -979,7 +979,7 @@ be_local_class(lv_theme,
be_nested_map(3, be_nested_map(3,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_theme_create) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_theme_create) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
})), })),
(be_nested_const_str("lv_theme", 1550958453, 7)) (be_nested_const_str("lv_theme", 1550958453, 7))

6
lib/libesp32_lvgl/lv_berry/library.json
View File

@ -4,8 +4,8 @@
"description": "Mapping of LVGL functions to Berry", "description": "Mapping of LVGL functions to Berry",
"license": "MIT", "license": "MIT",
"homepage": "https://github.com/arendst/Tasmota", "homepage": "https://github.com/arendst/Tasmota",
"frameworks": "arduino", "frameworks": "*",
"platforms": "espressif32", "platforms": "*",
"authors": "authors":
{ {
"name": "Stephan Hadinger", "name": "Stephan Hadinger",
@ -20,6 +20,6 @@
"+<*.cpp>", "+<*.cpp>",
"+<*.h>" "+<*.h>"
], ],
"flags": [ "-I$PROJECT_DIR/include" ] "flags": [ "-I$PROJECT_DIR/include", "-includetasmota_options.h" ]
} }
} }

911
lib/libesp32_lvgl/lv_berry/src/be_lvgl_glob_lib.c
View File

@ -40,11 +40,11 @@ be_local_closure(LVGL_glob_get_object_from_ptr, /* name */
/******************************************************************** /********************************************************************
** Solidified function: widget_event_impl ** Solidified function: widget_ctor_impl
********************************************************************/ ********************************************************************/
be_local_closure(LVGL_glob_widget_event_impl, /* name */ be_local_closure(LVGL_glob_widget_ctor_impl, /* name */
be_nested_proto( be_nested_proto(
12, /* nstack */ 10, /* nstack */
3, /* argc */ 3, /* argc */
0, /* varg */ 0, /* varg */
0, /* has upvals */ 0, /* has upvals */
@ -56,124 +56,16 @@ be_local_closure(LVGL_glob_widget_event_impl, /* name */
/* K0 */ be_nested_str(introspect), /* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv), /* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_obj_class), /* K2 */ be_nested_str(lv_obj_class),
/* K3 */ be_nested_str(lv_event), /* K3 */ be_nested_str(get_object_from_ptr),
/* K4 */ be_nested_str(target), /* K4 */ be_nested_str(cb_obj),
/* K5 */ be_nested_str(get_object_from_ptr), /* K5 */ be_nested_str(find),
/* K6 */ be_nested_str(instance), /* K6 */ be_nested_str(instance),
/* K7 */ be_nested_str(get), /* K7 */ be_nested_str(get),
/* K8 */ be_nested_str(widget_event), /* K8 */ be_nested_str(widget_constructor),
}), }),
&be_const_str_widget_event_impl, &be_const_str_widget_ctor_impl,
&be_const_str_solidified, &be_const_str_solidified,
( &(const binstruction[28]) { /* code */ ( &(const binstruction[29]) { /* code */
0xA40E0000, // 0000 IMPORT R3 K0
0xB8120200, // 0001 GETNGBL R4 K1
0x8C100902, // 0002 GETMET R4 R4 K2
0x5C180200, // 0003 MOVE R6 R1
0x7C100400, // 0004 CALL R4 2
0xB8160200, // 0005 GETNGBL R5 K1
0x8C140B03, // 0006 GETMET R5 R5 K3
0x5C1C0400, // 0007 MOVE R7 R2
0x7C140400, // 0008 CALL R5 2
0x88180B04, // 0009 GETMBR R6 R5 K4
0x8C1C0105, // 000A GETMET R7 R0 K5
0x5C240C00, // 000B MOVE R9 R6
0x7C1C0400, // 000C CALL R7 2
0x60200004, // 000D GETGBL R8 G4
0x5C240E00, // 000E MOVE R9 R7
0x7C200200, // 000F CALL R8 1
0x1C201106, // 0010 EQ R8 R8 K6
0x78220008, // 0011 JMPF R8 #001B
0x8C200707, // 0012 GETMET R8 R3 K7
0x5C280E00, // 0013 MOVE R10 R7
0x582C0008, // 0014 LDCONST R11 K8
0x7C200600, // 0015 CALL R8 3
0x78220003, // 0016 JMPF R8 #001B
0x8C200F08, // 0017 GETMET R8 R7 K8
0x5C280800, // 0018 MOVE R10 R4
0x5C2C0A00, // 0019 MOVE R11 R5
0x7C200600, // 001A CALL R8 3
0x80000000, // 001B RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: lvgl_event_dispatch
********************************************************************/
be_local_closure(LVGL_glob_lvgl_event_dispatch, /* name */
be_nested_proto(
10, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 7]) { /* constants */
/* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_event),
/* K3 */ be_nested_str(toptr),
/* K4 */ be_nested_str(target),
/* K5 */ be_nested_str(cb_event_closure),
/* K6 */ be_nested_str(get_object_from_ptr),
}),
&be_const_str_lvgl_event_dispatch,
&be_const_str_solidified,
( &(const binstruction[18]) { /* code */
0xA40A0000, // 0000 IMPORT R2 K0
0xB80E0200, // 0001 GETNGBL R3 K1
0x8C0C0702, // 0002 GETMET R3 R3 K2
0x8C140503, // 0003 GETMET R5 R2 K3
0x5C1C0200, // 0004 MOVE R7 R1
0x7C140400, // 0005 CALL R5 2
0x7C0C0400, // 0006 CALL R3 2
0x88100704, // 0007 GETMBR R4 R3 K4
0x88140105, // 0008 GETMBR R5 R0 K5
0x94140A04, // 0009 GETIDX R5 R5 R4
0x8C180106, // 000A GETMET R6 R0 K6
0x5C200800, // 000B MOVE R8 R4
0x7C180400, // 000C CALL R6 2
0x5C1C0A00, // 000D MOVE R7 R5
0x5C200C00, // 000E MOVE R8 R6
0x5C240600, // 000F MOVE R9 R3
0x7C1C0400, // 0010 CALL R7 2
0x80000000, // 0011 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: widget_dtor_impl
********************************************************************/
be_local_closure(LVGL_glob_widget_dtor_impl, /* name */
be_nested_proto(
10, /* nstack */
3, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 7]) { /* constants */
/* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_obj_class),
/* K3 */ be_nested_str(get_object_from_ptr),
/* K4 */ be_nested_str(instance),
/* K5 */ be_nested_str(get),
/* K6 */ be_nested_str(widget_destructor),
}),
&be_const_str_widget_dtor_impl,
&be_const_str_solidified,
( &(const binstruction[22]) { /* code */
0xA40E0000, // 0000 IMPORT R3 K0 0xA40E0000, // 0000 IMPORT R3 K0
0xB8120200, // 0001 GETNGBL R4 K1 0xB8120200, // 0001 GETNGBL R4 K1
0x8C100902, // 0002 GETMET R4 R4 K2 0x8C100902, // 0002 GETMET R4 R4 K2
@ -182,200 +74,27 @@ be_local_closure(LVGL_glob_widget_dtor_impl, /* name */
0x8C140103, // 0005 GETMET R5 R0 K3 0x8C140103, // 0005 GETMET R5 R0 K3
0x5C1C0400, // 0006 MOVE R7 R2 0x5C1C0400, // 0006 MOVE R7 R2
0x7C140400, // 0007 CALL R5 2 0x7C140400, // 0007 CALL R5 2
0x60180004, // 0008 GETGBL R6 G4 0x88180104, // 0008 GETMBR R6 R0 K4
0x5C1C0A00, // 0009 MOVE R7 R5 0x8C180D05, // 0009 GETMET R6 R6 K5
0x7C180200, // 000A CALL R6 1 0x5C200A00, // 000A MOVE R8 R5
0x1C180D04, // 000B EQ R6 R6 K4 0x7C180400, // 000B CALL R6 2
0x781A0007, // 000C JMPF R6 #0015 0x781A0001, // 000C JMPF R6 #000F
0x8C180705, // 000D GETMET R6 R3 K5 0x88180104, // 000D GETMBR R6 R0 K4
0x5C200A00, // 000E MOVE R8 R5 0x94140C05, // 000E GETIDX R5 R6 R5
0x58240006, // 000F LDCONST R9 K6 0x60180004, // 000F GETGBL R6 G4
0x7C180600, // 0010 CALL R6 3 0x5C1C0A00, // 0010 MOVE R7 R5
0x781A0002, // 0011 JMPF R6 #0015 0x7C180200, // 0011 CALL R6 1
0x8C180B06, // 0012 GETMET R6 R5 K6 0x1C180D06, // 0012 EQ R6 R6 K6
0x5C200800, // 0013 MOVE R8 R4 0x781A0007, // 0013 JMPF R6 #001C
0x7C180400, // 0014 CALL R6 2 0x8C180707, // 0014 GETMET R6 R3 K7
0x80000000, // 0015 RET 0 0x5C200A00, // 0015 MOVE R8 R5
}) 0x58240008, // 0016 LDCONST R9 K8
) 0x7C180600, // 0017 CALL R6 3
); 0x781A0002, // 0018 JMPF R6 #001C
/*******************************************************************/ 0x8C180B08, // 0019 GETMET R6 R5 K8
0x5C200800, // 001A MOVE R8 R4
0x7C180400, // 001B CALL R6 2
/******************************************************************** 0x80000000, // 001C RET 0
** Solidified function: register_obj
********************************************************************/
be_local_closure(LVGL_glob_register_obj, /* name */
be_nested_proto(
4, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_str(cb_obj),
/* K1 */ be_nested_str(_p),
}),
&be_const_str_register_obj,
&be_const_str_solidified,
( &(const binstruction[11]) { /* code */
0x88080100, // 0000 GETMBR R2 R0 K0
0x4C0C0000, // 0001 LDNIL R3
0x1C080403, // 0002 EQ R2 R2 R3
0x780A0002, // 0003 JMPF R2 #0007
0x60080013, // 0004 GETGBL R2 G19
0x7C080000, // 0005 CALL R2 0
0x90020002, // 0006 SETMBR R0 K0 R2
0x88080301, // 0007 GETMBR R2 R1 K1
0x880C0100, // 0008 GETMBR R3 R0 K0
0x980C0401, // 0009 SETIDX R3 R2 R1
0x80000000, // 000A RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: gen_cb
********************************************************************/
be_local_closure(LVGL_glob_gen_cb, /* name */
be_nested_proto(
8, /* nstack */
4, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
1, /* has sup protos */
( &(const struct bproto*[ 1]) {
be_nested_proto(
4, /* nstack */
1, /* argc */
0, /* varg */
1, /* has upvals */
( &(const bupvaldesc[ 1]) { /* upvals */
be_local_const_upval(1, 0),
}),
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 1]) { /* constants */
/* K0 */ be_nested_str(lvgl_event_dispatch),
}),
&be_const_str__X3Clambda_X3E,
&be_const_str_solidified,
( &(const binstruction[ 5]) { /* code */
0x68040000, // 0000 GETUPV R1 U0
0x8C040300, // 0001 GETMET R1 R1 K0
0x5C0C0000, // 0002 MOVE R3 R0
0x7C040400, // 0003 CALL R1 2
0x80040200, // 0004 RET 1 R1
})
),
}),
1, /* has constants */
( &(const bvalue[ 9]) { /* constants */
/* K0 */ be_nested_str(cb),
/* K1 */ be_nested_str(lv_event_cb),
/* K2 */ be_nested_str(cb_event_closure),
/* K3 */ be_nested_str(event_cb),
/* K4 */ be_nested_str(gen_cb),
/* K5 */ be_nested_str(register_obj),
/* K6 */ be_nested_str(_p),
/* K7 */ be_nested_str(null_cb),
/* K8 */ be_nested_str(cb_do_nothing),
}),
&be_const_str_gen_cb,
&be_const_str_solidified,
( &(const binstruction[41]) { /* code */
0xA4120000, // 0000 IMPORT R4 K0
0x1C140701, // 0001 EQ R5 R3 K1
0x78160018, // 0002 JMPF R5 #001C
0x88140102, // 0003 GETMBR R5 R0 K2
0x4C180000, // 0004 LDNIL R6
0x1C140A06, // 0005 EQ R5 R5 R6
0x78160002, // 0006 JMPF R5 #000A
0x60140013, // 0007 GETGBL R5 G19
0x7C140000, // 0008 CALL R5 0
0x90020405, // 0009 SETMBR R0 K2 R5
0x88140103, // 000A GETMBR R5 R0 K3
0x4C180000, // 000B LDNIL R6
0x1C140A06, // 000C EQ R5 R5 R6
0x78160003, // 000D JMPF R5 #0012
0x8C140904, // 000E GETMET R5 R4 K4
0x841C0000, // 000F CLOSURE R7 P0
0x7C140400, // 0010 CALL R5 2
0x90020605, // 0011 SETMBR R0 K3 R5
0x8C140105, // 0012 GETMET R5 R0 K5
0x5C1C0400, // 0013 MOVE R7 R2
0x7C140400, // 0014 CALL R5 2
0x88140506, // 0015 GETMBR R5 R2 K6
0x88180102, // 0016 GETMBR R6 R0 K2
0x98180A01, // 0017 SETIDX R6 R5 R1
0x88140103, // 0018 GETMBR R5 R0 K3
0xA0000000, // 0019 CLOSE R0
0x80040A00, // 001A RET 1 R5
0x7002000A, // 001B JMP #0027
0x88140107, // 001C GETMBR R5 R0 K7
0x4C180000, // 001D LDNIL R6
0x1C140A06, // 001E EQ R5 R5 R6
0x78160003, // 001F JMPF R5 #0024
0x8C140904, // 0020 GETMET R5 R4 K4
0x881C0108, // 0021 GETMBR R7 R0 K8
0x7C140400, // 0022 CALL R5 2
0x90020E05, // 0023 SETMBR R0 K7 R5
0x88140107, // 0024 GETMBR R5 R0 K7
0xA0000000, // 0025 CLOSE R0
0x80040A00, // 0026 RET 1 R5
0xA0000000, // 0027 CLOSE R0
0x80000000, // 0028 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: deregister_obj
********************************************************************/
be_local_closure(LVGL_glob_deregister_obj, /* name */
be_nested_proto(
5, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 3]) { /* constants */
/* K0 */ be_nested_str(cb_obj),
/* K1 */ be_nested_str(remove),
/* K2 */ be_nested_str(cb_event_closure),
}),
&be_const_str_deregister_obj,
&be_const_str_solidified,
( &(const binstruction[17]) { /* code */
0x88080100, // 0000 GETMBR R2 R0 K0
0x4C0C0000, // 0001 LDNIL R3
0x20080403, // 0002 NE R2 R2 R3
0x780A0003, // 0003 JMPF R2 #0008
0x88080100, // 0004 GETMBR R2 R0 K0
0x8C080501, // 0005 GETMET R2 R2 K1
0x5C100200, // 0006 MOVE R4 R1
0x7C080400, // 0007 CALL R2 2
0x88080102, // 0008 GETMBR R2 R0 K2
0x4C0C0000, // 0009 LDNIL R3
0x20080403, // 000A NE R2 R2 R3
0x780A0003, // 000B JMPF R2 #0010
0x88080102, // 000C GETMBR R2 R0 K2
0x8C080501, // 000D GETMET R2 R2 K1
0x5C100200, // 000E MOVE R4 R1
0x7C080400, // 000F CALL R2 2
0x80000000, // 0010 RET 0
}) })
) )
); );
@ -387,7 +106,7 @@ be_local_closure(LVGL_glob_deregister_obj, /* name */
********************************************************************/ ********************************************************************/
be_local_closure(LVGL_glob_widget_cb, /* name */ be_local_closure(LVGL_glob_widget_cb, /* name */
be_nested_proto( be_nested_proto(
4, /* nstack */ 5, /* nstack */
1, /* argc */ 1, /* argc */
0, /* varg */ 0, /* varg */
0, /* has upvals */ 0, /* has upvals */
@ -472,8 +191,8 @@ be_local_closure(LVGL_glob_widget_cb, /* name */
}), }),
1, /* has constants */ 1, /* has constants */
( &(const bvalue[15]) { /* constants */ ( &(const bvalue[15]) { /* constants */
/* K0 */ be_nested_str(widget_ctor_cb), /* K0 */ be_nested_str(cb),
/* K1 */ be_nested_str(tasmota), /* K1 */ be_nested_str(widget_ctor_cb),
/* K2 */ be_nested_str(gen_cb), /* K2 */ be_nested_str(gen_cb),
/* K3 */ be_nested_str(widget_dtor_cb), /* K3 */ be_nested_str(widget_dtor_cb),
/* K4 */ be_nested_str(widget_event_cb), /* K4 */ be_nested_str(widget_event_cb),
@ -490,63 +209,61 @@ be_local_closure(LVGL_glob_widget_cb, /* name */
}), }),
&be_const_str_widget_cb, &be_const_str_widget_cb,
&be_const_str_solidified, &be_const_str_solidified,
( &(const binstruction[56]) { /* code */ ( &(const binstruction[54]) { /* code */
0x88040100, // 0000 GETMBR R1 R0 K0 0xA4060000, // 0000 IMPORT R1 K0
0x4C080000, // 0001 LDNIL R2 0x88080101, // 0001 GETMBR R2 R0 K1
0x1C040202, // 0002 EQ R1 R1 R2 0x4C0C0000, // 0002 LDNIL R3
0x78060004, // 0003 JMPF R1 #0009 0x1C080403, // 0003 EQ R2 R2 R3
0xB8060200, // 0004 GETNGBL R1 K1 0x780A0003, // 0004 JMPF R2 #0009
0x8C040302, // 0005 GETMET R1 R1 K2 0x8C080302, // 0005 GETMET R2 R1 K2
0x840C0000, // 0006 CLOSURE R3 P0 0x84100000, // 0006 CLOSURE R4 P0
0x7C040400, // 0007 CALL R1 2 0x7C080400, // 0007 CALL R2 2
0x90020001, // 0008 SETMBR R0 K0 R1 0x90020202, // 0008 SETMBR R0 K1 R2
0x88040103, // 0009 GETMBR R1 R0 K3 0x88080103, // 0009 GETMBR R2 R0 K3
0x4C080000, // 000A LDNIL R2 0x4C0C0000, // 000A LDNIL R3
0x1C040202, // 000B EQ R1 R1 R2 0x1C080403, // 000B EQ R2 R2 R3
0x78060004, // 000C JMPF R1 #0012 0x780A0003, // 000C JMPF R2 #0011
0xB8060200, // 000D GETNGBL R1 K1 0x8C080302, // 000D GETMET R2 R1 K2
0x8C040302, // 000E GETMET R1 R1 K2 0x84100001, // 000E CLOSURE R4 P1
0x840C0001, // 000F CLOSURE R3 P1 0x7C080400, // 000F CALL R2 2
0x7C040400, // 0010 CALL R1 2 0x90020602, // 0010 SETMBR R0 K3 R2
0x90020601, // 0011 SETMBR R0 K3 R1 0x88080104, // 0011 GETMBR R2 R0 K4
0x88040104, // 0012 GETMBR R1 R0 K4 0x4C0C0000, // 0012 LDNIL R3
0x4C080000, // 0013 LDNIL R2 0x1C080403, // 0013 EQ R2 R2 R3
0x1C040202, // 0014 EQ R1 R1 R2 0x780A0003, // 0014 JMPF R2 #0019
0x78060004, // 0015 JMPF R1 #001B 0x8C080302, // 0015 GETMET R2 R1 K2
0xB8060200, // 0016 GETNGBL R1 K1 0x84100002, // 0016 CLOSURE R4 P2
0x8C040302, // 0017 GETMET R1 R1 K2 0x7C080400, // 0017 CALL R2 2
0x840C0002, // 0018 CLOSURE R3 P2 0x90020802, // 0018 SETMBR R0 K4 R2
0x7C040400, // 0019 CALL R1 2 0x88080105, // 0019 GETMBR R2 R0 K5
0x90020801, // 001A SETMBR R0 K4 R1 0x4C0C0000, // 001A LDNIL R3
0x88040105, // 001B GETMBR R1 R0 K5 0x1C080403, // 001B EQ R2 R2 R3
0x4C080000, // 001C LDNIL R2 0x780A0016, // 001C JMPF R2 #0034
0x1C040202, // 001D EQ R1 R1 R2 0xB80A0C00, // 001D GETNGBL R2 K6
0x78060016, // 001E JMPF R1 #0036 0x8C080507, // 001E GETMET R2 R2 K7
0xB8060C00, // 001F GETNGBL R1 K6 0xB8120C00, // 001F GETNGBL R4 K6
0x8C040307, // 0020 GETMET R1 R1 K7 0x88100908, // 0020 GETMBR R4 R4 K8
0xB80E0C00, // 0021 GETNGBL R3 K6 0x88100909, // 0021 GETMBR R4 R4 K9
0x880C0708, // 0022 GETMBR R3 R3 K8 0x7C080400, // 0022 CALL R2 2
0x880C0709, // 0023 GETMBR R3 R3 K9 0x8C08050A, // 0023 GETMET R2 R2 K10
0x7C040400, // 0024 CALL R1 2 0x7C080200, // 0024 CALL R2 1
0x8C04030A, // 0025 GETMET R1 R1 K10 0x90020A02, // 0025 SETMBR R0 K5 R2
0x7C040200, // 0026 CALL R1 1 0x88080105, // 0026 GETMBR R2 R0 K5
0x90020A01, // 0027 SETMBR R0 K5 R1 0xB80E0C00, // 0027 GETNGBL R3 K6
0x88040105, // 0028 GETMBR R1 R0 K5 0x880C0708, // 0028 GETMBR R3 R3 K8
0xB80A0C00, // 0029 GETNGBL R2 K6 0x880C0709, // 0029 GETMBR R3 R3 K9
0x88080508, // 002A GETMBR R2 R2 K8 0x900A1603, // 002A SETMBR R2 K11 R3
0x88080509, // 002B GETMBR R2 R2 K9 0x88080105, // 002B GETMBR R2 R0 K5
0x90061602, // 002C SETMBR R1 K11 R2 0x880C0101, // 002C GETMBR R3 R0 K1
0x88040105, // 002D GETMBR R1 R0 K5 0x900A1803, // 002D SETMBR R2 K12 R3
0x88080100, // 002E GETMBR R2 R0 K0 0x88080105, // 002E GETMBR R2 R0 K5
0x90061802, // 002F SETMBR R1 K12 R2 0x880C0103, // 002F GETMBR R3 R0 K3
0x88040105, // 0030 GETMBR R1 R0 K5 0x900A1A03, // 0030 SETMBR R2 K13 R3
0x88080103, // 0031 GETMBR R2 R0 K3 0x88080105, // 0031 GETMBR R2 R0 K5
0x90061A02, // 0032 SETMBR R1 K13 R2 0x880C0104, // 0032 GETMBR R3 R0 K4
0x88040105, // 0033 GETMBR R1 R0 K5 0x900A1C03, // 0033 SETMBR R2 K14 R3
0x88080104, // 0034 GETMBR R2 R0 K4 0xA0000000, // 0034 CLOSE R0
0x90061C02, // 0035 SETMBR R1 K14 R2 0x80000000, // 0035 RET 0
0xA0000000, // 0036 CLOSE R0
0x80000000, // 0037 RET 0
}) })
) )
); );
@ -720,9 +437,90 @@ be_local_closure(LVGL_glob_create_custom_widget, /* name */
/******************************************************************** /********************************************************************
** Solidified function: widget_ctor_impl ** Solidified function: register_obj
********************************************************************/ ********************************************************************/
be_local_closure(LVGL_glob_widget_ctor_impl, /* name */ be_local_closure(LVGL_glob_register_obj, /* name */
be_nested_proto(
4, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_str(cb_obj),
/* K1 */ be_nested_str(_p),
}),
&be_const_str_register_obj,
&be_const_str_solidified,
( &(const binstruction[11]) { /* code */
0x88080100, // 0000 GETMBR R2 R0 K0
0x4C0C0000, // 0001 LDNIL R3
0x1C080403, // 0002 EQ R2 R2 R3
0x780A0002, // 0003 JMPF R2 #0007
0x60080013, // 0004 GETGBL R2 G19
0x7C080000, // 0005 CALL R2 0
0x90020002, // 0006 SETMBR R0 K0 R2
0x88080301, // 0007 GETMBR R2 R1 K1
0x880C0100, // 0008 GETMBR R3 R0 K0
0x980C0401, // 0009 SETIDX R3 R2 R1
0x80000000, // 000A RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: deregister_obj
********************************************************************/
be_local_closure(LVGL_glob_deregister_obj, /* name */
be_nested_proto(
5, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 3]) { /* constants */
/* K0 */ be_nested_str(cb_obj),
/* K1 */ be_nested_str(remove),
/* K2 */ be_nested_str(cb_event_closure),
}),
&be_const_str_deregister_obj,
&be_const_str_solidified,
( &(const binstruction[17]) { /* code */
0x88080100, // 0000 GETMBR R2 R0 K0
0x4C0C0000, // 0001 LDNIL R3
0x20080403, // 0002 NE R2 R2 R3
0x780A0003, // 0003 JMPF R2 #0008
0x88080100, // 0004 GETMBR R2 R0 K0
0x8C080501, // 0005 GETMET R2 R2 K1
0x5C100200, // 0006 MOVE R4 R1
0x7C080400, // 0007 CALL R2 2
0x88080102, // 0008 GETMBR R2 R0 K2
0x4C0C0000, // 0009 LDNIL R3
0x20080403, // 000A NE R2 R2 R3
0x780A0003, // 000B JMPF R2 #0010
0x88080102, // 000C GETMBR R2 R0 K2
0x8C080501, // 000D GETMET R2 R2 K1
0x5C100200, // 000E MOVE R4 R1
0x7C080400, // 000F CALL R2 2
0x80000000, // 0010 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: widget_dtor_impl
********************************************************************/
be_local_closure(LVGL_glob_widget_dtor_impl, /* name */
be_nested_proto( be_nested_proto(
10, /* nstack */ 10, /* nstack */
3, /* argc */ 3, /* argc */
@ -732,49 +530,319 @@ be_local_closure(LVGL_glob_widget_ctor_impl, /* name */
0, /* has sup protos */ 0, /* has sup protos */
NULL, /* no sub protos */ NULL, /* no sub protos */
1, /* has constants */ 1, /* has constants */
( &(const bvalue[ 7]) { /* constants */
/* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_obj_class),
/* K3 */ be_nested_str(get_object_from_ptr),
/* K4 */ be_nested_str(instance),
/* K5 */ be_nested_str(get),
/* K6 */ be_nested_str(widget_destructor),
}),
&be_const_str_widget_dtor_impl,
&be_const_str_solidified,
( &(const binstruction[22]) { /* code */
0xA40E0000, // 0000 IMPORT R3 K0
0xB8120200, // 0001 GETNGBL R4 K1
0x8C100902, // 0002 GETMET R4 R4 K2
0x5C180200, // 0003 MOVE R6 R1
0x7C100400, // 0004 CALL R4 2
0x8C140103, // 0005 GETMET R5 R0 K3
0x5C1C0400, // 0006 MOVE R7 R2
0x7C140400, // 0007 CALL R5 2
0x60180004, // 0008 GETGBL R6 G4
0x5C1C0A00, // 0009 MOVE R7 R5
0x7C180200, // 000A CALL R6 1
0x1C180D04, // 000B EQ R6 R6 K4
0x781A0007, // 000C JMPF R6 #0015
0x8C180705, // 000D GETMET R6 R3 K5
0x5C200A00, // 000E MOVE R8 R5
0x58240006, // 000F LDCONST R9 K6
0x7C180600, // 0010 CALL R6 3
0x781A0002, // 0011 JMPF R6 #0015
0x8C180B06, // 0012 GETMET R6 R5 K6
0x5C200800, // 0013 MOVE R8 R4
0x7C180400, // 0014 CALL R6 2
0x80000000, // 0015 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: init
********************************************************************/
be_local_closure(LVGL_glob_init, /* name */
be_nested_proto(
5, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
1, /* has sup protos */
( &(const struct bproto*[ 1]) {
be_nested_proto(
8, /* nstack */
3, /* argc */
0, /* varg */
1, /* has upvals */
( &(const bupvaldesc[ 1]) { /* upvals */
be_local_const_upval(1, 0),
}),
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 1]) { /* constants */
/* K0 */ be_nested_str(make_cb),
}),
&be_const_str__X3Clambda_X3E,
&be_const_str_solidified,
( &(const binstruction[ 7]) { /* code */
0x680C0000, // 0000 GETUPV R3 U0
0x8C0C0700, // 0001 GETMET R3 R3 K0
0x5C140000, // 0002 MOVE R5 R0
0x5C180200, // 0003 MOVE R6 R1
0x5C1C0400, // 0004 MOVE R7 R2
0x7C0C0800, // 0005 CALL R3 4
0x80040600, // 0006 RET 1 R3
})
),
}),
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_str(cb),
/* K1 */ be_nested_str(add_handler),
}),
&be_const_str_init,
&be_const_str_solidified,
( &(const binstruction[ 6]) { /* code */
0xA4060000, // 0000 IMPORT R1 K0
0x8C080301, // 0001 GETMET R2 R1 K1
0x84100000, // 0002 CLOSURE R4 P0
0x7C080400, // 0003 CALL R2 2
0xA0000000, // 0004 CLOSE R0
0x80000000, // 0005 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: widget_event_impl
********************************************************************/
be_local_closure(LVGL_glob_widget_event_impl, /* name */
be_nested_proto(
12, /* nstack */
3, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 9]) { /* constants */ ( &(const bvalue[ 9]) { /* constants */
/* K0 */ be_nested_str(introspect), /* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv), /* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_obj_class), /* K2 */ be_nested_str(lv_obj_class),
/* K3 */ be_nested_str(get_object_from_ptr), /* K3 */ be_nested_str(lv_event),
/* K4 */ be_nested_str(cb_obj), /* K4 */ be_nested_str(target),
/* K5 */ be_nested_str(find), /* K5 */ be_nested_str(get_object_from_ptr),
/* K6 */ be_nested_str(instance), /* K6 */ be_nested_str(instance),
/* K7 */ be_nested_str(get), /* K7 */ be_nested_str(get),
/* K8 */ be_nested_str(widget_constructor), /* K8 */ be_nested_str(widget_event),
}), }),
&be_const_str_widget_ctor_impl, &be_const_str_widget_event_impl,
&be_const_str_solidified, &be_const_str_solidified,
( &(const binstruction[29]) { /* code */ ( &(const binstruction[28]) { /* code */
0xA40E0000, // 0000 IMPORT R3 K0 0xA40E0000, // 0000 IMPORT R3 K0
0xB8120200, // 0001 GETNGBL R4 K1 0xB8120200, // 0001 GETNGBL R4 K1
0x8C100902, // 0002 GETMET R4 R4 K2 0x8C100902, // 0002 GETMET R4 R4 K2
0x5C180200, // 0003 MOVE R6 R1 0x5C180200, // 0003 MOVE R6 R1
0x7C100400, // 0004 CALL R4 2 0x7C100400, // 0004 CALL R4 2
0x8C140103, // 0005 GETMET R5 R0 K3 0xB8160200, // 0005 GETNGBL R5 K1
0x5C1C0400, // 0006 MOVE R7 R2 0x8C140B03, // 0006 GETMET R5 R5 K3
0x7C140400, // 0007 CALL R5 2 0x5C1C0400, // 0007 MOVE R7 R2
0x88180104, // 0008 GETMBR R6 R0 K4 0x7C140400, // 0008 CALL R5 2
0x8C180D05, // 0009 GETMET R6 R6 K5 0x88180B04, // 0009 GETMBR R6 R5 K4
0x5C200A00, // 000A MOVE R8 R5 0x8C1C0105, // 000A GETMET R7 R0 K5
0x7C180400, // 000B CALL R6 2 0x5C240C00, // 000B MOVE R9 R6
0x781A0001, // 000C JMPF R6 #000F 0x7C1C0400, // 000C CALL R7 2
0x88180104, // 000D GETMBR R6 R0 K4 0x60200004, // 000D GETGBL R8 G4
0x94140C05, // 000E GETIDX R5 R6 R5 0x5C240E00, // 000E MOVE R9 R7
0x60180004, // 000F GETGBL R6 G4 0x7C200200, // 000F CALL R8 1
0x5C1C0A00, // 0010 MOVE R7 R5 0x1C201106, // 0010 EQ R8 R8 K6
0x7C180200, // 0011 CALL R6 1 0x78220008, // 0011 JMPF R8 #001B
0x1C180D06, // 0012 EQ R6 R6 K6 0x8C200707, // 0012 GETMET R8 R3 K7
0x781A0007, // 0013 JMPF R6 #001C 0x5C280E00, // 0013 MOVE R10 R7
0x8C180707, // 0014 GETMET R6 R3 K7 0x582C0008, // 0014 LDCONST R11 K8
0x5C200A00, // 0015 MOVE R8 R5 0x7C200600, // 0015 CALL R8 3
0x58240008, // 0016 LDCONST R9 K8 0x78220003, // 0016 JMPF R8 #001B
0x7C180600, // 0017 CALL R6 3 0x8C200F08, // 0017 GETMET R8 R7 K8
0x781A0002, // 0018 JMPF R6 #001C 0x5C280800, // 0018 MOVE R10 R4
0x8C180B08, // 0019 GETMET R6 R5 K8 0x5C2C0A00, // 0019 MOVE R11 R5
0x5C200800, // 001A MOVE R8 R4 0x7C200600, // 001A CALL R8 3
0x7C180400, // 001B CALL R6 2 0x80000000, // 001B RET 0
0x80000000, // 001C RET 0 })
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: make_cb
********************************************************************/
be_local_closure(LVGL_glob_make_cb, /* name */
be_nested_proto(
8, /* nstack */
4, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
1, /* has sup protos */
( &(const struct bproto*[ 1]) {
be_nested_proto(
4, /* nstack */
1, /* argc */
0, /* varg */
1, /* has upvals */
( &(const bupvaldesc[ 1]) { /* upvals */
be_local_const_upval(1, 0),
}),
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 1]) { /* constants */
/* K0 */ be_nested_str(lvgl_event_dispatch),
}),
&be_const_str__X3Clambda_X3E,
&be_const_str_solidified,
( &(const binstruction[ 5]) { /* code */
0x68040000, // 0000 GETUPV R1 U0
0x8C040300, // 0001 GETMET R1 R1 K0
0x5C0C0000, // 0002 MOVE R3 R0
0x7C040400, // 0003 CALL R1 2
0x80040200, // 0004 RET 1 R1
})
),
}),
1, /* has constants */
( &(const bvalue[12]) { /* constants */
/* K0 */ be_nested_str(cb),
/* K1 */ be_nested_str(lv_event_cb),
/* K2 */ be_nested_str(cb_event_closure),
/* K3 */ be_nested_str(event_cb),
/* K4 */ be_nested_str(gen_cb),
/* K5 */ be_nested_str(register_obj),
/* K6 */ be_nested_str(_p),
/* K7 */ be_const_int(0),
/* K8 */ be_const_int(2),
/* K9 */ be_nested_str(lv_),
/* K10 */ be_nested_str(null_cb),
/* K11 */ be_nested_str(cb_do_nothing),
}),
&be_const_str_make_cb,
&be_const_str_solidified,
( &(const binstruction[49]) { /* code */
0xA4120000, // 0000 IMPORT R4 K0
0x1C140701, // 0001 EQ R5 R3 K1
0x78160018, // 0002 JMPF R5 #001C
0x88140102, // 0003 GETMBR R5 R0 K2
0x4C180000, // 0004 LDNIL R6
0x1C140A06, // 0005 EQ R5 R5 R6
0x78160002, // 0006 JMPF R5 #000A
0x60140013, // 0007 GETGBL R5 G19
0x7C140000, // 0008 CALL R5 0
0x90020405, // 0009 SETMBR R0 K2 R5
0x88140103, // 000A GETMBR R5 R0 K3
0x4C180000, // 000B LDNIL R6
0x1C140A06, // 000C EQ R5 R5 R6
0x78160003, // 000D JMPF R5 #0012
0x8C140904, // 000E GETMET R5 R4 K4
0x841C0000, // 000F CLOSURE R7 P0
0x7C140400, // 0010 CALL R5 2
0x90020605, // 0011 SETMBR R0 K3 R5
0x8C140105, // 0012 GETMET R5 R0 K5
0x5C1C0400, // 0013 MOVE R7 R2
0x7C140400, // 0014 CALL R5 2
0x88140506, // 0015 GETMBR R5 R2 K6
0x88180102, // 0016 GETMBR R6 R0 K2
0x98180A01, // 0017 SETIDX R6 R5 R1
0x88140103, // 0018 GETMBR R5 R0 K3
0xA0000000, // 0019 CLOSE R0
0x80040A00, // 001A RET 1 R5
0x70020012, // 001B JMP #002F
0x40160F08, // 001C CONNECT R5 K7 K8
0x94140605, // 001D GETIDX R5 R3 R5
0x1C140B09, // 001E EQ R5 R5 K9
0x7816000B, // 001F JMPF R5 #002C
0x8814010A, // 0020 GETMBR R5 R0 K10
0x4C180000, // 0021 LDNIL R6
0x1C140A06, // 0022 EQ R5 R5 R6
0x78160003, // 0023 JMPF R5 #0028
0x8C140904, // 0024 GETMET R5 R4 K4
0x881C010B, // 0025 GETMBR R7 R0 K11
0x7C140400, // 0026 CALL R5 2
0x90021405, // 0027 SETMBR R0 K10 R5
0x8814010A, // 0028 GETMBR R5 R0 K10
0xA0000000, // 0029 CLOSE R0
0x80040A00, // 002A RET 1 R5
0x70020002, // 002B JMP #002F
0x4C140000, // 002C LDNIL R5
0xA0000000, // 002D CLOSE R0
0x80040A00, // 002E RET 1 R5
0xA0000000, // 002F CLOSE R0
0x80000000, // 0030 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: lvgl_event_dispatch
********************************************************************/
be_local_closure(LVGL_glob_lvgl_event_dispatch, /* name */
be_nested_proto(
10, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 7]) { /* constants */
/* K0 */ be_nested_str(introspect),
/* K1 */ be_nested_str(lv),
/* K2 */ be_nested_str(lv_event),
/* K3 */ be_nested_str(toptr),
/* K4 */ be_nested_str(target),
/* K5 */ be_nested_str(cb_event_closure),
/* K6 */ be_nested_str(get_object_from_ptr),
}),
&be_const_str_lvgl_event_dispatch,
&be_const_str_solidified,
( &(const binstruction[18]) { /* code */
0xA40A0000, // 0000 IMPORT R2 K0
0xB80E0200, // 0001 GETNGBL R3 K1
0x8C0C0702, // 0002 GETMET R3 R3 K2
0x8C140503, // 0003 GETMET R5 R2 K3
0x5C1C0200, // 0004 MOVE R7 R1
0x7C140400, // 0005 CALL R5 2
0x7C0C0400, // 0006 CALL R3 2
0x88100704, // 0007 GETMBR R4 R3 K4
0x88140105, // 0008 GETMBR R5 R0 K5
0x94140A04, // 0009 GETIDX R5 R5 R4
0x8C180106, // 000A GETMET R6 R0 K6
0x5C200800, // 000B MOVE R8 R4
0x7C180400, // 000C CALL R6 2
0x5C1C0A00, // 000D MOVE R7 R5
0x5C200C00, // 000E MOVE R8 R6
0x5C240600, // 000F MOVE R9 R3
0x7C1C0400, // 0010 CALL R7 2
0x80000000, // 0011 RET 0
}) })
) )
); );
@ -787,28 +855,29 @@ be_local_closure(LVGL_glob_widget_ctor_impl, /* name */
be_local_class(LVGL_glob, be_local_class(LVGL_glob,
9, 9,
NULL, NULL,
be_nested_map(20, be_nested_map(21,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_const_key(widget_ctor_cb, 8), be_const_var(4) }, { be_const_key(get_object_from_ptr, 7), be_const_closure(LVGL_glob_get_object_from_ptr_closure) },
{ be_const_key(get_object_from_ptr, 4), be_const_closure(LVGL_glob_get_object_from_ptr_closure) }, { be_const_key(widget_ctor_impl, 6), be_const_closure(LVGL_glob_widget_ctor_impl_closure) },
{ be_const_key(cb_obj, 7), be_const_var(0) },
{ be_const_key(widget_struct_by_class, -1), be_const_var(8) },
{ be_const_key(widget_event_impl, -1), be_const_closure(LVGL_glob_widget_event_impl_closure) },
{ be_const_key(widget_dtor_cb, 6), be_const_var(5) },
{ be_const_key(cb_event_closure, -1), be_const_var(1) },
{ be_const_key(cb_do_nothing, 16), be_const_static_closure(LVGL_glob__anonymous__closure) },
{ be_const_key(null_cb, -1), be_const_var(3) },
{ be_const_key(register_obj, -1), be_const_closure(LVGL_glob_register_obj_closure) },
{ be_const_key(widget_dtor_impl, 9), be_const_closure(LVGL_glob_widget_dtor_impl_closure) },
{ be_const_key(gen_cb, -1), be_const_closure(LVGL_glob_gen_cb_closure) },
{ be_const_key(deregister_obj, -1), be_const_closure(LVGL_glob_deregister_obj_closure) },
{ be_const_key(widget_struct_default, 12), be_const_var(7) },
{ be_const_key(widget_event_cb, -1), be_const_var(6) },
{ be_const_key(widget_cb, -1), be_const_closure(LVGL_glob_widget_cb_closure) }, { be_const_key(widget_cb, -1), be_const_closure(LVGL_glob_widget_cb_closure) },
{ be_const_key(lvgl_event_dispatch, 3), be_const_closure(LVGL_glob_lvgl_event_dispatch_closure) }, { be_const_key(lvgl_event_dispatch, -1), be_const_closure(LVGL_glob_lvgl_event_dispatch_closure) },
{ be_const_key(cb_do_nothing, 10), be_const_static_closure(LVGL_glob__anonymous__closure) },
{ be_const_key(widget_struct_by_class, -1), be_const_var(8) },
{ be_const_key(cb_event_closure, 19), be_const_var(1) },
{ be_const_key(widget_dtor_impl, -1), be_const_closure(LVGL_glob_widget_dtor_impl_closure) },
{ be_const_key(register_obj, -1), be_const_closure(LVGL_glob_register_obj_closure) },
{ be_const_key(deregister_obj, -1), be_const_closure(LVGL_glob_deregister_obj_closure) },
{ be_const_key(widget_event_cb, -1), be_const_var(6) },
{ be_const_key(widget_ctor_cb, -1), be_const_var(4) },
{ be_const_key(init, -1), be_const_closure(LVGL_glob_init_closure) },
{ be_const_key(widget_event_impl, -1), be_const_closure(LVGL_glob_widget_event_impl_closure) },
{ be_const_key(widget_dtor_cb, -1), be_const_var(5) },
{ be_const_key(cb_obj, 11), be_const_var(0) },
{ be_const_key(make_cb, -1), be_const_closure(LVGL_glob_make_cb_closure) },
{ be_const_key(null_cb, -1), be_const_var(3) },
{ be_const_key(event_cb, -1), be_const_var(2) }, { be_const_key(event_cb, -1), be_const_var(2) },
{ be_const_key(create_custom_widget, -1), be_const_closure(LVGL_glob_create_custom_widget_closure) }, { be_const_key(create_custom_widget, -1), be_const_closure(LVGL_glob_create_custom_widget_closure) },
{ be_const_key(widget_ctor_impl, -1), be_const_closure(LVGL_glob_widget_ctor_impl_closure) }, { be_const_key(widget_struct_default, 3), be_const_var(7) },
})), })),
be_str_literal("LVGL_glob") be_str_literal("LVGL_glob")
); );

21
lib/libesp32_lvgl/lv_berry/src/embedded/lvgl_glob.be
View File

@ -20,6 +20,12 @@ class LVGL_glob
#- this is the fallback callback, if the event is unknown or unsupported -# #- this is the fallback callback, if the event is unknown or unsupported -#
static cb_do_nothing = def() print("LVG: call to unsupported callback") end static cb_do_nothing = def() print("LVG: call to unsupported callback") end
# register our callback handler to `module cb`
def init()
import cb
cb.add_handler(/ f, obj, name -> self.make_cb(f, obj, name))
end
#- register an lv.lv_* object in the mapping -# #- register an lv.lv_* object in the mapping -#
def register_obj(obj) def register_obj(obj)
if self.cb_obj == nil self.cb_obj = {} end if self.cb_obj == nil self.cb_obj = {} end
@ -44,9 +50,9 @@ class LVGL_glob
f(obj, event) f(obj, event)
end end
def gen_cb(f, obj, name) def make_cb(f, obj, name)
import cb import cb
# print('>> gen_cb', f, name, obj) # print('>> make_cb', f, name, obj)
# record the object, whatever the callback # record the object, whatever the callback
if name == "lv_event_cb" if name == "lv_event_cb"
@ -57,9 +63,11 @@ class LVGL_glob
self.cb_event_closure[obj._p] = f self.cb_event_closure[obj._p] = f
return self.event_cb return self.event_cb
# elif name == "<other_cb>" # elif name == "<other_cb>"
else elif name[0..2] == "lv_"
if self.null_cb == nil self.null_cb = cb.gen_cb(self.cb_do_nothing) end if self.null_cb == nil self.null_cb = cb.gen_cb(self.cb_do_nothing) end
return self.null_cb return self.null_cb
else
return nil # the call is not for us, pass to next handler
end end
end end
@ -96,9 +104,10 @@ class LVGL_glob
def widget_cb() def widget_cb()
if self.widget_ctor_cb == nil self.widget_ctor_cb = tasmota.gen_cb(/ cl, obj -> self.widget_ctor_impl(cl, obj)) end import cb
if self.widget_dtor_cb == nil self.widget_dtor_cb = tasmota.gen_cb(/ cl, obj -> self.widget_dtor_impl(cl, obj)) end if self.widget_ctor_cb == nil self.widget_ctor_cb = cb.gen_cb(/ cl, obj -> self.widget_ctor_impl(cl, obj)) end
if self.widget_event_cb == nil self.widget_event_cb = tasmota.gen_cb(/ cl, e -> self.widget_event_impl(cl, e)) end if self.widget_dtor_cb == nil self.widget_dtor_cb = cb.gen_cb(/ cl, obj -> self.widget_dtor_impl(cl, obj)) end
if self.widget_event_cb == nil self.widget_event_cb = cb.gen_cb(/ cl, e -> self.widget_event_impl(cl, e)) end
if self.widget_struct_default == nil if self.widget_struct_default == nil
self.widget_struct_default = lv.lv_obj_class(lv.lv_obj._class).copy() self.widget_struct_default = lv.lv_obj_class(lv.lv_obj._class).copy()

287
lib/libesp32_lvgl/lv_berry/src/lv_berry.c
View File

@ -1,4 +1,13 @@
#include "lv_berry.h" #include "lv_berry.h"
#include "be_mapping.h"
#include "be_exec.h"
#include "be_vm.h"
#include "be_mem.h"
#include <stdio.h>
#include "../generate/be_lv_c_mapping.h"
extern void be_load_lv_color_class(bvm *vm); extern void be_load_lv_color_class(bvm *vm);
extern void be_load_lv_font_class(bvm *vm); extern void be_load_lv_font_class(bvm *vm);
@ -9,3 +18,281 @@ void be_load_lvgl_classes(bvm *vm) {
be_load_lv_font_class(vm); be_load_lv_font_class(vm);
be_load_LVGL_glob_class(vm); be_load_LVGL_glob_class(vm);
} }
/*********************************************************************************************\
* Support for lv
\*********************************************************************************************/
// Get the `_p` member of instance at `index`
void * lv_get_arg(bvm *vm, int index) {
void * ret = NULL;
if (be_isinstance(vm, index)) {
be_getmember(vm, index, "_p");
ret = be_tocomptr(vm, -1);
be_pop(vm, 1); // remove _p attribute
}
return ret;
}
/*********************************************************************************************\
* Support for lv_indev and objects that don't need creator
\*********************************************************************************************/
int lv0_init(bvm *vm);
int lv0_init(bvm *vm) {
// "+_p" indicates that there must be an non NULL argument, either passed as comptr or returned by the function
// Here, there is no function, so calling the constructor without a non-null comptr argument is rejected
return be_call_c_func(vm, NULL, "+_p", NULL);
}
/*********************************************************************************************\
* Generalized tostring method, shows class and _p value
\*********************************************************************************************/
int lv_x_tostring(bvm *vm) {
lv_obj_t * obj = (lv_obj_t*) lv_get_arg(vm, 1);
const char * classname = be_classname(vm, 1);
char s[48];
snprintf(s, sizeof(s), "<instance: %s(0x%08X)>", classname, obj);
be_pushnstring(vm, s, strlen(s)); /* make escape string from buffer */
be_return(vm);
}
/*********************************************************************************************\
* Support for lv_style
\*********************************************************************************************/
int lvs_init(bvm *vm) {
int argc = be_top(vm);
lv_style_t * style = NULL;
if (argc > 1) {
style = (lv_style_t*) be_convert_single_elt(vm, 2, NULL, NULL);
}
if (style == NULL) {
style = (lv_style_t*) be_malloc(vm, sizeof(lv_style_t));
if (style == NULL) {
be_throw(vm, BE_MALLOC_FAIL);
}
if (style != NULL) {
lv_style_init(style);
}
}
be_pushcomptr(vm, style);
be_setmember(vm, 1, "_p");
be_return_nil(vm);
}
// native closure to call `be_call_c_func`
int lv_x_call_c(bvm *vm) {
// berry_log_C("lv_x_call_c enter");
// 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("lv_x_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 lv_x_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("lv_x_member looking for method '%s' of class '%s'", method_name, class_name);
// look for class descriptor
int32_t class_idx = be_map_bin_search(class_name, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
if (class_idx >= 0) {
const be_ntv_func_def_t * methods_calls = lv_classes[class_idx].func_table;
size_t methods_size = lv_classes[class_idx].size;
int32_t method_idx = be_map_bin_search(method_name, methods_calls, sizeof(be_ntv_func_def_t), methods_size);
if (method_idx >= 0) {
// method found
const be_ntv_func_def_t * method = &methods_calls[method_idx];
// berry_log_C("lv_x_member method found func=%p return_type=%s arg_type=%s", method->func, method->return_type, method->arg_type);
// push native closure
be_pushntvclosure(vm, &lv_x_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("lv_x_member method not found");
be_return_nil(vm);
}
be_raise(vm, "type_error", NULL);
}
// lv_color
// First arg is a 24 bits RGB color
// If first arg is `nil` second arg is the native value of color
int lco_init(bvm *vm) {
int argc = be_top(vm);
uint32_t color32 = 0x000000; // default to black
if (argc > 1) {
color32 = be_toint(vm, 2);
}
lv_color_t lv_color = lv_color_hex(color32);
if (argc > 2 && be_toint(vm, 3) == -1) {
lv_color.full = be_toint(vm, 2);
}
be_pushint(vm, lv_color_to_uint32(lv_color));
be_setmember(vm, 1, "_p");
be_return_nil(vm);
}
int lco_tostring(bvm *vm) {
lv_color_t lv_color = {};
be_getmember(vm, 1, "_p");
uint32_t ntv_color = be_toint(vm, -1);
lv_color = lv_color_from_uint32(ntv_color);
uint32_t color = lv_color_to32(lv_color) & 0xFFFFFF;
be_pop(vm, 1); // remove attribute
char s[48];
snprintf(s, sizeof(s), "lv_color(0x%06x - native:0x%04x)", color, ntv_color);
be_pushnstring(vm, s, strlen(s)); /* make escape string from buffer */
be_return(vm);
}
int lco_toint(bvm *vm) {
lv_color_t lv_color = {};
be_getmember(vm, 1, "_p");
uint32_t ntv_color = be_toint(vm, -1);
be_pushint(vm, ntv_color);
be_return(vm);
}
// function is (void) -> lv_obt_t*
typedef lv_obj_t* (*fn_lvobj__void)(void); // f() -> newly created lv_obj()
int lv0_lvobj__void_call(bvm *vm, fn_lvobj__void func) {
lv_obj_t * obj = (*func)();
be_find_global_or_module_member(vm, "lv.lv_obj");
be_pushcomptr(vm, (void*) -1); // stack = class, -1
be_pushcomptr(vm, (void*) obj); // stack = class, -1, ptr
be_call(vm, 2); // instanciate, stack = instance (don't call init() )
be_pop(vm, 2); // stack = instance
be_return(vm);
}
/*********************************************************************************************\
* Support for lv_fonts
\*********************************************************************************************/
// load font by name on file-system
int lv0_load_font(bvm *vm) {
int argc = be_top(vm);
if (argc == 1 && be_isstring(vm, 1)) {
lv_font_t * font = lv_font_load(be_tostring(vm, 1));
if (font != NULL) {
be_find_global_or_module_member(vm, "lv.lv_font");
be_pushcomptr(vm, font);
be_call(vm, 1);
be_pop(vm, 1);
be_return(vm);
} else {
be_return_nil(vm);
}
}
be_raise(vm, "type_error", NULL);
}
/*********************************************************************************************\
* LVGL top level virtual members
*
* Responds to virtual constants
\*********************************************************************************************/
extern const be_ntv_func_def_t lv_func[];
extern const size_t lv_func_size;
extern const be_const_member_t lv0_constants[];
extern const size_t lv0_constants_size;
extern const be_ctypes_class_by_name_t be_ctypes_lvgl_classes[];
extern const size_t be_ctypes_lvgl_classes_size;
int lv0_member(bvm *vm);
int lv0_member(bvm *vm) {
// first try the standard way
if (be_const_member(vm, lv0_constants, lv0_constants_size)) {
be_return(vm);
}
// try alternative members
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 idx;
// search for a class with this name
char cl_prefixed[32];
snprintf(cl_prefixed, sizeof(cl_prefixed), "lv_%s", needle); // we try both actual name and prefixed with `lv_` so both `lv.obj` and `lv.lv_obj` work
idx = be_map_bin_search(cl_prefixed, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
if (idx < 0) {
idx = be_map_bin_search(needle, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
}
if (idx >= 0) {
// we did have a match
be_pushntvclass(vm, lv_classes[idx].cl);
be_return(vm);
}
// same search for ctypes
idx = be_map_bin_search(cl_prefixed, &be_ctypes_lvgl_classes[0].name, sizeof(be_ctypes_lvgl_classes[0]), be_ctypes_lvgl_classes_size);
if (idx < 0) {
idx = be_map_bin_search(needle, &be_ctypes_lvgl_classes[0].name, sizeof(be_ctypes_lvgl_classes[0]), be_ctypes_lvgl_classes_size);
}
if (idx >= 0) {
// we did have a match
be_pushntvclass(vm, be_ctypes_lvgl_classes[idx].cl);
be_return(vm);
}
// search for a method with this name
idx = be_map_bin_search(needle, &lv_func[0].name, sizeof(lv_func[0]), lv_func_size);
if (idx >= 0) {
const be_ntv_func_def_t * method = &lv_func[idx];
// push native closure
be_pushntvclosure(vm, &lv_x_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);
}
}
be_return_nil(vm);
}

16
lib/libesp32_lvgl/lv_berry/src/lv_berry.h
View File

@ -8,9 +8,25 @@ extern "C" {
#endif #endif
#include "berry.h" #include "berry.h"
#include "lvgl.h"
/*********************************************************************************************\
* Support for lv_color
\*********************************************************************************************/
inline lv_color_t lv_color_from_uint32(uint32_t ucol) {
lv_color_t * col = (lv_color_t*) &ucol;
return *col;
}
inline uint32_t lv_color_to_uint32(lv_color_t col) {
uint16_t *p = (uint16_t*) &col;
return *p;
}
extern void be_load_lvgl_classes(bvm *vm); extern void be_load_lvgl_classes(bvm *vm);
// TODO temporary fix
extern void lv_img_set_tasmota_logo(lv_obj_t * img);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

30
lib/libesp32_lvgl/lv_berry/tools/convert.py
View File

@ -433,11 +433,11 @@ extern int lco_init(bvm *vm); // generic function
extern int lco_tostring(bvm *vm); // generic function extern int lco_tostring(bvm *vm); // generic function
extern int lco_toint(bvm *vm); // generic function extern int lco_toint(bvm *vm); // generic function
extern int lvx_member(bvm *vm); extern int lv_x_member(bvm *vm);
extern int lvx_tostring(bvm *vm); // generic function extern int lv_x_tostring(bvm *vm); // generic function
extern int lvs_init(bvm *vm); extern int lvs_init(bvm *vm);
extern int lvs_tostring(bvm *vm); extern int lv_x_tostring(bvm *vm);
BE_EXPORT_VARIABLE extern const bclass be_class_lv_obj; BE_EXPORT_VARIABLE extern const bclass be_class_lv_obj;
@ -484,9 +484,9 @@ be_local_class(lv_style,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvs_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvs_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvs_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_style", -143355747, 8)) (be_nested_const_str("lv_style", -143355747, 8))
); );
@ -500,8 +500,8 @@ be_local_class(lv_obj,
NULL, NULL,
be_nested_map(5, be_nested_map(5,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("tostring", -1995258651, 8, 3), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, 3), be_const_func(lv_x_tostring) },
{ be_nested_key("member", 719708611, 6, -1), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, -1), be_const_func(lv_x_member) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("init", 380752755, 4, 4), be_const_func(be_ntv_lv_obj_init) }, { be_nested_key("init", 380752755, 4, 4), be_const_func(be_ntv_lv_obj_init) },
{ be_nested_key("_class", -1562820946, 6, -1), be_const_comptr(&lv_obj_class) }, { be_nested_key("_class", -1562820946, 6, -1), be_const_comptr(&lv_obj_class) },
@ -519,9 +519,9 @@ be_local_class(lv_group,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(be_ntv_lv_group_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(be_ntv_lv_group_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_group", -442928277, 8)) (be_nested_const_str("lv_group", -442928277, 8))
); );
@ -536,9 +536,9 @@ be_local_class(lv_indev,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_indev", 225602374, 8)) (be_nested_const_str("lv_indev", 225602374, 8))
); );
@ -553,9 +553,9 @@ be_local_class(lv_disp,
be_nested_map(4, be_nested_map(4,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lv0_init) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
{ be_nested_key("member", 719708611, 6, 0), be_const_func(lvx_member) }, { be_nested_key("member", 719708611, 6, 0), be_const_func(lv_x_member) },
})), })),
(be_nested_const_str("lv_disp", 609712084, 8)) (be_nested_const_str("lv_disp", 609712084, 8))
); );
@ -570,7 +570,7 @@ be_local_class(lv_font,
be_nested_map(3, be_nested_map(3,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_font_create) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_font_create) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
})), })),
(be_nested_const_str("lv_font", 1550958453, 7)) (be_nested_const_str("lv_font", 1550958453, 7))
@ -586,7 +586,7 @@ be_local_class(lv_theme,
be_nested_map(3, be_nested_map(3,
( (struct bmapnode*) &(const bmapnode[]) { ( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_theme_create) }, { be_nested_key("init", 380752755, 4, -1), be_const_func(lvbe_theme_create) },
{ be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lvx_tostring) }, { be_nested_key("tostring", -1995258651, 8, -1), be_const_func(lv_x_tostring) },
{ be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) }, { be_nested_key("_p", 1594591802, 2, -1), be_const_var(0) },
})), })),
(be_nested_const_str("lv_theme", 1550958453, 7)) (be_nested_const_str("lv_theme", 1550958453, 7))

7
tasmota/berry/lvgl_examples/widget_test.be
View File

@ -23,9 +23,10 @@ def eventcb(class_p, e)
print(string.format("> event class_p=0x%08X event=%s obj=%s code=%i", print(string.format("> event class_p=0x%08X event=%s obj=%s code=%i",
class_p, str(event), str(obj), event_code)) class_p, str(event), str(obj), event_code))
end end
var cb_ctor = tasmota.gen_cb(ctorcb) import cb
var cb_dtor = tasmota.gen_cb(dtorcb) var cb_ctor = cb.gen_cb(ctorcb)
var cb_event = tasmota.gen_cb(eventcb) var cb_dtor = cb.gen_cb(dtorcb)
var cb_event = cb.gen_cb(eventcb)
# static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e) # static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)

1097
tasmota/lvgl_berry/be_lv_c_mapping.h
View File

File diff suppressed because it is too large Load Diff

6
tasmota/lvgl_berry/tasmota_lv_stdlib.h
View File

@ -1,18 +1,14 @@
/* /*
tasmota_lv_stdlib.h - internationalization for Tasmota tasmota_lv_stdlib.h - internationalization for Tasmota
Copyright (C) 2021 Theo Arends Copyright (C) 2021 Theo Arends
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
@ -21,4 +17,4 @@
extern void *lvbe_malloc(size_t size); 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); extern void *lvbe_realloc(void *ptr, size_t size);

313
tasmota/xdrv_52_3_berry_lvgl.ino
View File

@ -104,76 +104,7 @@ extern void lv_ex_get_started_1(void);
extern "C" { extern "C" {
void lv_init_set_member(bvm *vm, int index, void * ptr);
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) {
// berry_log_C("lvx_call_c enter");
// 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 = be_map_bin_search(class_name, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
if (class_idx >= 0) {
const be_ntv_func_def_t * methods_calls = lv_classes[class_idx].func_table;
size_t methods_size = lv_classes[class_idx].size;
int32_t method_idx = be_map_bin_search(method_name, methods_calls, sizeof(be_ntv_func_def_t), methods_size);
if (method_idx >= 0) {
// method found
const be_ntv_func_def_t * method = &methods_calls[method_idx];
// berry_log_C("lvx_member method found func=%p return_type=%s arg_type=%s", method->func, method->return_type, method->arg_type);
// 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);
}
} }
/*********************************************************************************************\ /*********************************************************************************************\
@ -186,116 +117,6 @@ extern "C" {
\*********************************************************************************************/ \*********************************************************************************************/
extern "C" { extern "C" {
#include "be_exec.h"
#include "be_vm.h"
#include "be_mem.h"
/*********************************************************************************************\
* Support for lv_color
\*********************************************************************************************/
inline lv_color_t lv_color_from_uint32(uint32_t ucol) {
lv_color_t * col = (lv_color_t*) &ucol;
return *col;
}
inline uint32_t lv_color_to_uint32(lv_color_t col) {
uint16_t *p = (uint16_t*) &col;
return *p;
}
// lv_color
// First arg is a 24 bits RGB color
// If first arg is `nil` second arg is the native value of color
int lco_init(bvm *vm) {
int argc = be_top(vm);
uint32_t color32 = 0x000000; // default to black
if (argc > 1) {
color32 = be_toint(vm, 2);
}
lv_color_t lv_color = lv_color_hex(color32);
if (argc > 2 && be_toint(vm, 3) == -1) {
lv_color.full = be_toint(vm, 2);
}
be_pushint(vm, lv_color_to_uint32(lv_color));
be_setmember(vm, 1, "_p");
be_return_nil(vm);
}
int lco_tostring(bvm *vm) {
lv_color_t lv_color = {};
be_getmember(vm, 1, "_p");
uint32_t ntv_color = be_toint(vm, -1);
lv_color = lv_color_from_uint32(ntv_color);
uint32_t color = lv_color_to32(lv_color) & 0xFFFFFF;
be_pop(vm, 1); // remove attribute
char s[48];
snprintf(s, sizeof(s), "lv_color(0x%06x - native:0x%04x)", color, ntv_color);
be_pushnstring(vm, s, strlen(s)); /* make escape string from buffer */
be_return(vm);
}
int lco_toint(bvm *vm) {
lv_color_t lv_color = {};
be_getmember(vm, 1, "_p");
uint32_t ntv_color = be_toint(vm, -1);
be_pushint(vm, ntv_color);
be_return(vm);
}
/*********************************************************************************************\
* Support for lv
\*********************************************************************************************/
// Get the `_p` member of instance at `index`
void * lv_get_arg(bvm *vm, int index) {
void * ret = nullptr;
if (be_isinstance(vm, index)) {
be_getmember(vm, index, "_p");
ret = be_tocomptr(vm, -1);
be_pop(vm, 1); // remove _p attribute
}
return ret;
}
// called during init, set the `_p` member with the pointer
void lv_init_set_member(bvm *vm, int index, void * ptr) {
be_pushcomptr(vm, ptr);
be_setmember(vm, index, "_p");
be_pop(vm, 1);
}
// function is (void) -> lv_obt_t*
typedef lv_obj_t* (*fn_lvobj__void)(void); // f() -> newly created lv_obj()
int lv0_lvobj__void_call(bvm *vm, fn_lvobj__void func) {
lv_obj_t * obj = (*func)();
be_find_global_or_module_member(vm, "lv.lv_obj");
be_pushcomptr(vm, (void*) -1); // stack = class, -1
be_pushcomptr(vm, (void*) obj); // stack = class, -1, ptr
be_call(vm, 2); // instanciate, stack = instance (don't call init() )
be_pop(vm, 2); // stack = instance
be_return(vm);
}
/*********************************************************************************************\
* Support for lv_fonts
\*********************************************************************************************/
// load font by name on file-system
int lv0_load_font(bvm *vm) {
int argc = be_top(vm);
if (argc == 1 && be_isstring(vm, 1)) {
lv_font_t * font = lv_font_load(be_tostring(vm, 1));
if (font != nullptr) {
be_find_global_or_module_member(vm, "lv.lv_font");
be_pushcomptr(vm, font);
be_call(vm, 1);
be_pop(vm, 1);
be_return(vm);
} else {
be_return_nil(vm);
}
}
be_raise(vm, kTypeError, nullptr);
}
/*********************************************************************************************\ /*********************************************************************************************\
* Support for Freetype fonts * Support for Freetype fonts
@ -540,82 +361,6 @@ extern "C" {
lv_img_set_src(img, &tasmota_logo_64_truecolor); lv_img_set_src(img, &tasmota_logo_64_truecolor);
} }
/*********************************************************************************************\
* LVGL top level virtual members
*
* Responds to virtual constants
\*********************************************************************************************/
extern const be_ntv_func_def_t lv_func[];
extern const size_t lv_func_size;
extern const be_const_member_t lv0_constants[];
extern const size_t lv0_constants_size;
extern const be_ctypes_class_by_name_t be_ctypes_lvgl_classes[];
extern const size_t be_ctypes_lvgl_classes_size;
int lv0_member(bvm *vm);
int lv0_member(bvm *vm) {
// first try the standard way
if (be_const_member(vm, lv0_constants, lv0_constants_size)) {
be_return(vm);
}
// try alternative members
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 idx;
// search for a class with this name
char cl_prefixed[32];
snprintf(cl_prefixed, sizeof(cl_prefixed), "lv_%s", needle); // we try both actual name and prefixed with `lv_` so both `lv.obj` and `lv.lv_obj` work
idx = be_map_bin_search(cl_prefixed, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
if (idx < 0) {
idx = be_map_bin_search(needle, &lv_classes[0].name, sizeof(lv_classes[0]), lv_classes_size);
}
if (idx >= 0) {
// we did have a match
be_pushntvclass(vm, lv_classes[idx].cl);
be_return(vm);
}
// same search for ctypes
idx = be_map_bin_search(cl_prefixed, &be_ctypes_lvgl_classes[0].name, sizeof(be_ctypes_lvgl_classes[0]), be_ctypes_lvgl_classes_size);
if (idx < 0) {
idx = be_map_bin_search(needle, &be_ctypes_lvgl_classes[0].name, sizeof(be_ctypes_lvgl_classes[0]), be_ctypes_lvgl_classes_size);
}
if (idx >= 0) {
// we did have a match
be_pushntvclass(vm, be_ctypes_lvgl_classes[idx].cl);
be_return(vm);
}
// search for a method with this name
idx = be_map_bin_search(needle, &lv_func[0].name, sizeof(lv_func[0]), lv_func_size);
if (idx >= 0) {
const be_ntv_func_def_t * method = &lv_func[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);
}
}
be_return_nil(vm);
}
/*********************************************************************************************\ /*********************************************************************************************\
* LVGL Start * LVGL Start
* *
@ -724,62 +469,6 @@ extern "C" {
} }
} }
/*********************************************************************************************\
* Support for lv_indev and objects that don't need creator
\*********************************************************************************************/
int lv0_init(bvm *vm);
int lv0_init(bvm *vm) {
void * obj = nullptr;
int argc = be_top(vm);
if (argc > 1) {
obj = (void*) be_convert_single_elt(vm, 2, NULL, NULL);
}
lv_init_set_member(vm, 1, obj);
be_return_nil(vm);
}
/*********************************************************************************************\
* Generalized tostring method, shows class and _p value
\*********************************************************************************************/
int lvx_tostring(bvm *vm) {
lv_obj_t * obj = (lv_obj_t*) lv_get_arg(vm, 1);
const char * classname = be_classname(vm, 1);
char s[48];
snprintf(s, sizeof(s), "<instance: %s(0x%08X)>", classname, obj);
be_pushnstring(vm, s, strlen(s)); /* make escape string from buffer */
be_return(vm);
}
/*********************************************************************************************\
* Support for lv_style
\*********************************************************************************************/
int lvs_init(bvm *vm) {
int argc = be_top(vm);
lv_style_t * style = nullptr;
if (argc > 1) {
style = (lv_style_t*) be_convert_single_elt(vm, 2, NULL, NULL);
}
if (style == nullptr) {
style = (lv_style_t*) be_malloc(vm, sizeof(lv_style_t));
if (style == nullptr) {
be_throw(vm, BE_MALLOC_FAIL);
}
if (style != nullptr) {
lv_style_init(style);
}
}
lv_init_set_member(vm, 1, style);
be_return_nil(vm);
}
int lvs_tostring(bvm *vm) {
lv_style_t * style1 = (lv_style_t*) lv_get_arg(vm, 1);
char s[32];
snprintf(s, sizeof(s), "<instance: lv_style(0x%08X)>", style1);
be_pushnstring(vm, s, strlen(s)); /* make escape string from buffer */
be_return(vm);
}
/*********************************************************************************************\ /*********************************************************************************************\
* Screenshot in raw format * Screenshot in raw format
\********************************************************************************************/ \********************************************************************************************/
@ -847,8 +536,6 @@ extern "C" {
} }
} }
#include "lvgl_berry/be_lv_c_mapping.h"
#else // USE_LVGL #else // USE_LVGL
// // define weak aliases // // define weak aliases