mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Tasmota/lib/libesp32/Berry/default/embedded/openhasp.be

765 lines
22 KiB
Plaintext
Raw Blame History

import string
import json
# lv.start()
# scr = lv.scr_act() # default screean object
# scr.set_style_bg_color(lv.color(0x0000A0), lv.PART_MAIN | lv.STATE_DEFAULT)
lv.start()
hres = lv.get_hor_res() # should be 320
vres = lv.get_ver_res() # should be 240
scr = lv.scr_act() # default screean object
#f20 = lv.montserrat_font(20) # load embedded Montserrat 20
r20 = lv.font_robotocondensed_latin1(20)
r16 = lv.font_robotocondensed_latin1(16)
th2 = lv.theme_openhasp_init(0, lv.color(0xFF00FF), lv.color(0x303030), false, r16)
scr.get_disp().set_theme(th2)
# TODO
scr.set_style_bg_color(lv.color(lv.COLOR_WHITE),0)
# apply theme to layer_top, but keep it transparent
lv.theme_apply(lv.layer_top())
lv.layer_top().set_style_bg_opa(0,0)
# takes an attribute name and responds if it needs color conversion
def is_color_attribute(t)
import string
t = str(t)
# contains `color` but does not contain `color_`
return (string.find(t, "color") >= 0) && (string.find(t, "color_") < 0)
end
# parse hex string
def parse_hex(s)
import string
s = string.toupper(s) # turn to uppercase
var val = 0
for i:0..size(s)-1
var c = s[i]
# var c_int = string.byte(c)
if c == "#" continue end # skip '#' prefix if any
if c == "x" || c == "X" continue end # skip 'x' or 'X'
if c >= "A" && c <= "F"
val = (val << 4) | string.byte(c) - 55
elif c >= "0" && c <= "9"
val = (val << 4) | string.byte(c) - 48
end
end
return val
end
def parse_color(s)
s = str(s)
if s[0] == '#'
return lv.color(parse_hex(s))
else
import string
import introspect
var col_name = "COLOR_" + string.toupper(s)
var col_try = introspect.get(lv, col_name)
if col_try != nil
return lv.color(col_try)
end
end
# fail safe with black color
return lv.color(0x000000)
end
#- ------------------------------------------------------------
Class `lvh_obj` encapsulating `lv_obj``
Provide a mapping for virtual members
Stores the associated page and object id
Adds specific virtual members used by OpenHASP
- ------------------------------------------------------------ -#
class lvh_obj
# _lv_class refers to the lvgl class encapsulated, and is overriden by subclasses
static _lv_class = lv.obj
static _lv_part2_selector # selector for secondary part (like knob of arc)
# attributes to ignore when set at object level (they are managed by page)
static _attr_ignore = [
"id",
"obj",
"page",
"comment",
"parentid",
"auto_size", # TODO not sure it's still needed in LVGL8
]
#- mapping from OpenHASP attribute to LVGL attribute -#
#- if mapping is null, we use set_X and get_X from our own class -#
static _attr_map = {
"x": "x",
"y": "y",
"w": "width",
"h": "height",
# arc
"asjustable": nil,
"mode": nil,
"start_angle": "bg_start_angle",
"start_angle1": "start_angle",
"end_angle": "bg_end_angle",
"end_angle1": "end_angle",
"radius": "style_radius",
"border_side": "style_border_side",
"bg_opa": "style_bg_opa",
"border_width": "style_border_width",
"line_width": nil, # depebds on class
"line_width1": nil, # depebds on class
"action": nil, # store the action in self._action
"hidden": nil, # apply to self
"enabled": nil, # apply to self
"click": nil, # synonym to enabled
"toggle": nil,
"bg_color": "style_bg_color",
"bg_grad_color": "style_bg_grad_color",
"type": nil,
# below automatically create a sub-label
"text": nil, # apply to self
"value_str": nil, # synonym to 'text'
"align": nil,
"text_font": nil,
"value_font": nil, # synonym to text_font
"text_color": nil,
"value_color": nil, # synonym to text_color
"value_ofs_x": nil,
"value_ofs_y": nil,
#
"min": nil,
"max": nil,
"val": "value",
"rotation": "rotation",
# img
"src": "src",
"image_recolor": "style_img_recolor",
"image_recolor_opa": "style_img_recolor_opa",
# spinner
"angle": nil,
"speed": nil,
# padding of knob
"pad_top2": nil,
"pad_bottom2": nil,
"pad_left2": nil,
"pad_right2": nil,
"pad_all2": nil,
"radius2": nil,
}
var _lv_obj # native lvgl object
var _lv_label # sub-label if exists
var _action # action for OpenHASP
# init
# - create the LVGL encapsulated object
# arg1: parent object
# arg2: json line object
def init(parent, jline)
var obj_class = self._lv_class # need to assign to a var to distinguish from method call
self._lv_obj = obj_class(parent) # instanciate LVGL object
self.post_init()
end
# post-init, to be overriden
def post_init()
end
# get LVGL encapsulated object
def get_obj()
return self._lv_obj
end
def set_action(t)
self._action = str(t)
end
def get_action()
return self._action()
end
def set_line_width(t)
self._lv_obj.set_style_line_width(int(t), lv.PART_MAIN | lv.STATE_DEFAULT)
end
def get_line_width()
return self._lv_obj.get_style_line_width(lv.PART_MAIN | lv.STATE_DEFAULT)
end
#- ------------------------------------------------------------
Mapping of synthetic attributes
- text
- hidden
- enabled
- ------------------------------------------------------------ -#
#- `hidden` attributes mapped to OBJ_FLAG_HIDDEN -#
def set_hidden(h)
if h
self._lv_obj.add_flag(lv.OBJ_FLAG_HIDDEN)
else
self._lv_obj.clear_flag(lv.OBJ_FLAG_HIDDEN)
end
end
def get_hidden()
return self._lv_obj.has_flag(lv.OBJ_FLAG_HIDDEN)
end
#- `enabled` attributes mapped to OBJ_FLAG_CLICKABLE -#
def set_enabled(h)
if h
self._lv_obj.add_flag(lv.OBJ_FLAG_CLICKABLE)
else
self._lv_obj.clear_flag(lv.OBJ_FLAG_CLICKABLE)
end
end
def get_enabled()
return self._lv_obj.has_flag(lv.OBJ_FLAG_CLICKABLE)
end
# click is synonym to enabled
def set_click(t) self.set_enabled(t) end
def get_click() return self.get_enabled() end
#- `toggle` attributes mapped to STATE_CHECKED -#
def set_toggle(t)
if t == "TRUE" t = true end
if t == "FALSE" t = false end
if t
self._lv_obj.add_state(lv.STATE_CHECKED)
else
self._lv_obj.clear_state(lv.STATE_CHECKED)
end
end
def get_toggle()
return self._lv_obj.has_state(lv.STATE_CHECKED)
end
def set_adjustable(t)
if t
self._lv_obj.add_flag(lv.OBJ_FLAG_CLICKABLE)
else
self._lv_obj.clear_flag(lv.OBJ_FLAG_CLICKABLE)
end
end
def get_adjustable()
return self._lv_obj.has_flag(lv.OBJ_FLAG_CLICKABLE)
end
#- set_text: create a `lv_label` sub object to the current object -#
#- (default case, may be overriden by object that directly take text) -#
def check_label()
if self._lv_label == nil
self._lv_label = lv.label(self.get_obj())
self._lv_label.set_align(lv.ALIGN_CENTER);
end
end
def set_text(t)
self.check_label()
self._lv_label.set_text(str(t))
end
def set_value_str(t) self.set_text(t) end
def get_text()
if self._lv_label == nil return nil end
return self._lv_label.get_text()
end
def get_value_str() return self.get_text() end
def set_align(t)
var align
self.check_label()
if t == 0 || t == "left"
align = lv.TEXT_ALIGN_LEFT
elif t == 1 || t == "center"
align = lv.TEXT_ALIGN_CENTER
elif t == 2 || t == "right"
align = lv.TEXT_ALIGN_RIGHT
end
self._lv_label.set_style_text_align(align, lv.PART_MAIN | lv.STATE_DEFAULT)
end
def get_align()
if self._lv_label == nil return nil end
var align self._lv_label.get_style_text_align(lv.PART_MAIN | lv.STATE_DEFAULT)
if align == lv.TEXT_ALIGN_LEFT
return "left"
elif align == lv.TEXT_ALIGN_CENTER
return "center"
elif align == lv.TEXT_ALIGN_RIGHT
return "right"
else
return nil
end
end
def set_text_font(t)
self.check_label()
var f = lv.font_robotocondensed_latin1(int(t))
if f != nil
self._lv_label.set_style_text_font(f, lv.PART_MAIN | lv.STATE_DEFAULT)
else
print("HSP: Unsupported font size: robotocondensed-latin1", t)
end
end
def get_text_font()
end
def set_value_font(t) self.set_text_font(t) end
def get_value_font() return self.get_text_font() end
def set_text_color(t)
self.check_label()
self._lv_label.set_style_text_color(parse_color(t), lv.PART_MAIN | lv.STATE_DEFAULT)
end
def get_text_color()
return self._text_color
end
def set_value_color(t) self.set_text_color(t) end
def get_value_color() return self.get_value_color() end
def set_value_ofs_x(t)
self.check_label()
self._lv_label.set_x(int(t))
end
def get_value_ofs_x()
return self._lv_label.get_x()
end
def set_value_ofs_y(t)
self.check_label()
self._lv_label.set_y(int(t))
end
def get_value_ofs_y()
return self._lv_label.get_y()
end
# secondary element
def set_pad_top2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_pad_top(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def set_pad_bottom2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_pad_bottom(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def set_pad_left2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_pad_left(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def set_pad_right2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_pad_right(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def set_pad_all2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_pad_all(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_pad_top()
if self._lv_part2_selector != nil
return self._lv_obj.get_style_pad_top(self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_pad_bottomo()
if self._lv_part2_selector != nil
return self._lv_obj.get_style_pad_bottom(self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_pad_left()
if self._lv_part2_selector != nil
return self._lv_obj.get_style_pad_left(self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_pad_right()
if self._lv_part2_selector != nil
return self._lv_obj.get_style_pad_right(self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_pad_all()
end
def set_radius2(t)
if self._lv_part2_selector != nil
self._lv_obj.set_style_radius(int(t), self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
def get_radius2()
if self._lv_part2_selector != nil
return self._lv_obj.get_style_radius(self._lv_part2_selector | lv.STATE_DEFAULT)
end
end
#- ------------------------------------------------------------
Mapping of virtual attributes
- ------------------------------------------------------------ -#
def member(k)
# tostring is a special case, we shouldn't raise an exception for it
if k == 'tostring' return nil end
#
if self._attr_map.has(k)
import introspect
var kv = self._attr_map[k]
if kv
var f = introspect.get(self._lv_obj, "get_" + kv)
if type(f) == 'function'
return f(self._lv_obj)
end
else
# call self method
var f = introspect.get(self, "get_" + k)
if type(f) == 'function'
return f(self, k)
end
end
end
raise "value_error", "unknown attribute " + str(k)
end
def setmember(k, v)
import string
# print(">> setmember", k, v)
# print(">>", classname(self), self._attr_map)
if self._attr_ignore.find(k) != nil
return
elif self._attr_map.has(k)
import introspect
var kv = self._attr_map[k]
if kv
var f = introspect.get(self._lv_obj, "set_" + kv)
# if the attribute contains 'color', convert to lv_color
if type(kv) == 'string' && is_color_attribute(kv)
v = parse_color(v)
end
# print("f=", f, v, kv, self._lv_obj, self)
if type(f) == 'function'
if string.find(kv, "style_") == 0
# style function need a selector as second parameter
f(self._lv_obj, v, lv.PART_MAIN | lv.STATE_DEFAULT)
else
f(self._lv_obj, v)
end
return
else
print("HSP: Could not find function set_"+kv)
end
else
# call self method
var f = introspect.get(self, "set_" + k)
# print("f==",f)
if type(f) == 'function'
f(self, v)
return
end
end
else
print("HSP: unknown attribute:", k)
end
# silently ignore if the attribute name is not supported
end
end
#- ------------------------------------------------------------
Other widgets
- ------------------------------------------------------------ -#
#- ------------------------------------------------------------
label
#- ------------------------------------------------------------#
class lvh_label : lvh_obj
static _lv_class = lv.label
# label do not need a sub-label
def post_init()
self._lv_label = self._lv_obj
end
end
#- ------------------------------------------------------------
arc
#- ------------------------------------------------------------#
class lvh_arc : lvh_obj
static _lv_class = lv.arc
static _lv_part2_selector = lv.PART_KNOB
# line_width converts to arc_width
def set_line_width(t)
self._lv_obj.set_style_arc_width(int(t), lv.PART_MAIN | lv.STATE_DEFAULT)
end
def get_line_width()
return self._lv_obj.get_arc_line_width(lv.PART_MAIN | lv.STATE_DEFAULT)
end
def set_line_width1(t)
self._lv_obj.set_style_arc_width(int(t), lv.PART_INDICATOR | lv.STATE_DEFAULT)
end
def get_line_width1()
return self._lv_obj.get_arc_line_width(lv.PART_INDICATOR | lv.STATE_DEFAULT)
end
def set_min(t)
self._lv_obj.set_range(int(t), self.get_max())
end
def set_max(t)
self._lv_obj.set_range(self.get_min(), int(t))
end
def get_min()
return self._lv_obj.get_min_value()
end
def get_max()
return self._lv_obj.get_max_value()
end
def set_type(t)
var mode
if t == 0 mode = lv.ARC_MODE_NORMAL
elif t == 1 mode = lv.ARC_MODE_REVERSE
elif t == 2 mode = lv.ARC_MODE_SYMMETRICAL
end
if mode != nil
self._lv_obj.set_mode(mode)
end
end
def get_type()
return self._lv_obj.get_mode()
end
# mode
def set_mode(t)
var mode
if mode == "expand" self._lv_obj.set_width(lv.SIZE_CONTENT)
elif mode == "break" mode = lv.LABEL_LONG_WRAP
elif mode == "dots" mode = lv.LABEL_LONG_DOT
elif mode == "scroll" mode = lv.LABEL_LONG_SCROLL
elif mode == "loop" mode = lv.LABEL_LONG_SCROLL_CIRCULAR
elif mode == "crop" mode = lv.LABEL_LONG_CLIP
end
if mode != nil
self._lv_obj.lv_label_set_long_mode(mode)
end
end
def get_mode()
end
end
#- ------------------------------------------------------------
switch
#- ------------------------------------------------------------#
class lvh_switch : lvh_obj
static _lv_class = lv.switch
static _lv_part2_selector = lv.PART_KNOB
end
#- ------------------------------------------------------------
spinner
#- ------------------------------------------------------------#
class lvh_spinner : lvh_arc
static _lv_class = lv.spinner
# init
# - create the LVGL encapsulated object
# arg1: parent object
# arg2: json line object
def init(parent, jline)
var angle = jline.find("angle", 60)
var speed = jline.find("speed", 1000)
self._lv_obj = lv.spinner(parent, speed, angle)
self.post_init()
end
# ignore attributes, spinner can't be changed once created
def set_angle(t) end
def get_angle() end
def set_speed(t) end
def get_speed() end
end
#- creat sub-classes of lvh_obj and map the LVGL class in static '_lv_class' attribute -#
class lvh_bar : lvh_obj static _lv_class = lv.bar end
class lvh_btn : lvh_obj static _lv_class = lv.btn end
class lvh_btnmatrix : lvh_obj static _lv_class = lv.btnmatrix end
class lvh_checkbox : lvh_obj static _lv_class = lv.checkbox end
class lvh_dropdown : lvh_obj static _lv_class = lv.dropdown end
class lvh_img : lvh_obj static _lv_class = lv.img end
class lvh_line : lvh_obj static _lv_class = lv.line end
class lvh_roller : lvh_obj static _lv_class = lv.roller end
class lvh_slider : lvh_obj static _lv_class = lv.slider end
class lvh_textarea : lvh_obj static _lv_class = lv.textarea end
#- ----------------------------------------------------------------------------
Class `lvh_page` encapsulating `lv_obj` as screen (created with lv.obj(0))
- ----------------------------------------------------------------------------- -#
# ex of transition: lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM_MOVE_RIGHT, 500, 0, false)
class lvh_page
var _obj_id # (map) of objects by id numbers
var _page_id # (int) id number of the page
var _lv_scr # (lv_obj) lvgl screen object
#- init(page_number) -#
def init(page_number)
import global
# if no parameter, default to page #1
if page_number == nil page_number = 1 end
self._page_id = page_number # remember our page_number
self._obj_id = {} # init list of objects
if page_number == 1
self._lv_scr = lv.scr_act() # default screen
elif page_number == 0
self._lv_scr = lv.layer_top() # top layer, visible over all screens
else
self._lv_scr = lv.obj(0) # allocate a new screen
# self._lv_scr.set_style_bg_color(lv.color(0x000000), lv.PART_MAIN | lv.STATE_DEFAULT) # set black background
self._lv_scr.set_style_bg_color(lv.color(0xFFFFFF), lv.PART_MAIN | lv.STATE_DEFAULT) # set white background
end
# create a global for this page of form p<page_number>, ex p1
var glob_name = string.format("p%i", self._page_id)
global.(glob_name) = self
end
#- retrieve lvgl screen object for this page -#
def get_scr()
return self._lv_scr
end
#- add an object to this page -#
def set_obj(id, o)
self._obj_id[id] = o
end
def get_obj(id)
return self._obj_id.find(id)
end
#- return id of this page -#
def id()
return self._page_id
end
#- show this page, with animation -#
def show(anim, duration)
# ignore if there is no screen, like for id 0
if self._lv_scr == nil return nil end
# ignore if the screen is already active
if self._lv_scr._p == lv.scr_act()._p return end # do nothing
# default animation is lv.SCR_LOAD_ANIM_MOVE_RIGHT
if anim == nil anim = lv.SCR_LOAD_ANIM_MOVE_RIGHT end
# default duration of 500ms
if duration == nil duration = 500 end
# load new screen with anumation, no delay, 500ms transition time, no auto-delete
lv.scr_load_anim(self._lv_scr, lv.SCR_LOAD_ANIM_MOVE_RIGHT, duration, 0, false)
end
end
#- pages -#
var lvh_page_cur = lvh_page(1)
var lvh_pages = { 1: lvh_page_cur } # always create page #1
f = open("pages.jsonl","r")
var jsonl = string.split(f.read(), "\n")
f.close()
#- ------------------------------------------------------------
Parse page information
Create a new page object if required
Change the active page
- ------------------------------------------------------------ -#
def parse_page(jline)
if jline.has("page") && type(jline["page"]) == 'int'
var page = int(jline["page"])
# does the page already exist?
if lvh_pages.has(page)
# yes, just change the current page
lvh_page_cur = lvh_pages[page]
else
# no, create a new page
lvh_page_cur = lvh_page(page)
lvh_pages[page] = lvh_page_cur
end
end
end
#- ------------------------------------------------------------
Parse single object
- ------------------------------------------------------------ -#
def parse_obj(jline, page)
import global
import introspect
# line must contain 'obj' and 'id', otherwise it is ignored
if jline.has("obj") && jline.has("id") && type(jline["id"]) == 'int'
# 'obj_id' must be between 1 and 254
var obj_id = int(jline["id"])
if obj_id < 1 || obj_id > 254
raise "value error", "invalid id " + str(obj_id)
end
# extract openhasp class, prefix with `lvh_`. Ex: `btn` becomes `lvh_btn`
var obj_type = jline["obj"]
# extract parent
var parent
var parent_id = int(jline.find("parentid"))
if parent_id != nil
var parent_obj = lvh_page_cur.get_obj(parent_id)
if parent_obj != nil
parent = parent_obj._lv_obj
end
end
if parent == nil
parent = page.get_scr()
end
# check if a class with the requested name exists
var obj_class = introspect.get(global, "lvh_" + obj_type)
if obj_class == nil
raise "value error", "cannot find object of type " + str(obj_type)
end
# instanciate the object, passing the lvgl screen as paren object
var obj = obj_class(parent, jline)
# add object to page object
lvh_page_cur.set_obj(obj_id, obj)
# set attributes
# try every attribute, if not supported it is silently ignored
for k:jline.keys()
# introspect.set(obj, k, jline[k])
obj.(k) = jline[k]
end
# create a global variable for this object of form p<page>b<id>, ex p1b2
var glob_name = string.format("p%ib%i", lvh_page_cur.id(), obj_id)
global.(glob_name) = obj
end
end
# ex:
# {'page': 1, 'h': 50, 'obj': 'label', 'hidden': false, 'text': 'Hello', 'x': 5, 'id': 1, 'enabled': true, 'y': 5, 'w': 50}
# {"page":1,"id":2,"obj":"btn","x":5,"y":90,"h":90,"w":50,"text":"World","enabled":false,"hidden":false}
#- ------------------------------------------------------------
Parse jsonl file line by line
- ------------------------------------------------------------ -#
tasmota.yield()
for j:jsonl
var jline = json.load(j)
# parse page first
if type(jline) == 'instance'
parse_page(jline)
parse_obj(jline, lvh_page_cur)
end
end
Reference in New Issue View Git Blame Copy Permalink